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: Use Au in ComputedValuesExt (#33396)

Browse source 
* Use app unit in `ComputedValuesExt`

Co-authored-by: Martin Robinson <mrobinson@igalia.com>
Signed-off-by: atbrakhi <atbrakhi@igalia.com>

* Some miscellaneous fixes

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

* remove redundant defination of `containing_block_inline_size`

Signed-off-by: atbrakhi <atbrakhi@igalia.com>

---------

Signed-off-by: atbrakhi <atbrakhi@igalia.com>
Signed-off-by: Martin Robinson <mrobinson@igalia.com>
Co-authored-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
atbrakhi 2024-09-10 23:35:17 +02:00 • committed by GitHub
parent 9346d9cc8d
commit 095590e224
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 240 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/layout_2020/display_list/stacking_context.rs
View file

@ -1507,12 +1507,12 @@ impl BoxFragment {
let transform_origin = &self.style.get_box().transform_origin; let transform_origin = &self.style.get_box().transform_origin;
let transform_origin_x = transform_origin let transform_origin_x = transform_origin
.horizontal .horizontal
.percentage_relative_to(border_rect.size.width.into()) .to_used_value(border_rect.size.width)
.px(); .to_f32_px();
let transform_origin_y = transform_origin let transform_origin_y = transform_origin
.vertical .vertical
.percentage_relative_to(border_rect.size.height.into()) .to_used_value(border_rect.size.height)
.px(); .to_f32_px();
let transform_origin_z = transform_origin.depth.px(); let transform_origin_z = transform_origin.depth.px();
let pre_transform = LayoutTransform::translation( let pre_transform = LayoutTransform::translation(

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

@ -15,7 +15,6 @@ use style::properties::longhands::box_sizing::computed_value::T as BoxSizing;
use style::properties::longhands::flex_wrap::computed_value::T as FlexWrap; use style::properties::longhands::flex_wrap::computed_value::T as FlexWrap;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::length::Size; use style::values::computed::length::Size;
use style::values::computed::Length;
use style::values::generics::flex::GenericFlexBasis as FlexBasis; use style::values::generics::flex::GenericFlexBasis as FlexBasis;
use style::values::generics::length::{GenericLengthPercentageOrAuto, LengthPercentageOrNormal}; use style::values::generics::length::{GenericLengthPercentageOrAuto, LengthPercentageOrNormal};
use style::values::specified::align::AlignFlags; use style::values::specified::align::AlignFlags;
@ -938,15 +937,12 @@ impl FlexContainer {
let min_box_size = self let min_box_size = self
.style .style
.content_min_box_size(containing_block_for_container, &pbm) .content_min_box_size(containing_block_for_container, &pbm)
.auto_is(Length::zero); .auto_is(Au::zero);
let max_box_size = self.config.flex_axis.vec2_to_flex_relative(max_box_size); let max_box_size = self.config.flex_axis.vec2_to_flex_relative(max_box_size);
let min_box_size = self.config.flex_axis.vec2_to_flex_relative(min_box_size); let min_box_size = self.config.flex_axis.vec2_to_flex_relative(min_box_size);
( (min_box_size.cross, max_box_size.cross.map(Into::into))
min_box_size.cross.into(),
max_box_size.cross.map(Into::into),
)
} }
} }
@ -1042,7 +1038,7 @@ impl<'a> FlexItem<'a> {
let item_with_auto_cross_size_stretches_to_container_size = flex_context let item_with_auto_cross_size_stretches_to_container_size = flex_context
.config .config
.item_with_auto_cross_size_stretches_to_container_size(&box_.style(), &margin); .item_with_auto_cross_size_stretches_to_container_size(box_.style(), &margin);
let flex_relative_content_box_size = flex_context.vec2_to_flex_relative(content_box_size); let flex_relative_content_box_size = flex_context.vec2_to_flex_relative(content_box_size);
let flex_relative_content_max_size = flex_context.vec2_to_flex_relative(max_size); let flex_relative_content_max_size = flex_context.vec2_to_flex_relative(max_size);
@ -2361,8 +2357,8 @@ impl FlexItemBox {
Some(container_definite_main_size) => { Some(container_definite_main_size) => {
let length = length_percentage let length = length_percentage
.0 .0
.percentage_relative_to(container_definite_main_size.into()); .to_used_value(container_definite_main_size);
FlexBasis::Size(apply_box_sizing(length.into())) FlexBasis::Size(apply_box_sizing(length))
}, },
None => { None => {
if let Some(length) = length_percentage.0.to_length() { if let Some(length) = length_percentage.0.to_length() {

9
components/layout_2020/flow/inline/line.rs
View file

@ -370,12 +370,9 @@ impl<'layout_data, 'layout> LineItemLayout<'layout_data, 'layout> {
let ifc_writing_mode = self.layout.containing_block.effective_writing_mode(); let ifc_writing_mode = self.layout.containing_block.effective_writing_mode();
for fragment in inner_state.fragments.iter_mut() { for fragment in inner_state.fragments.iter_mut() {
match fragment { if let Fragment::Float(box_fragment) = fragment {
Fragment::Float(box_fragment) => { box_fragment.content_rect.origin -=
box_fragment.content_rect.origin -= pbm_sums.start_offset().to_physical_size(ifc_writing_mode);
pbm_sums.start_offset().to_physical_size(ifc_writing_mode);
},
_ => {},
} }
} }

10
components/layout_2020/flow/inline/mod.rs
View file

@ -96,7 +96,7 @@ use style::computed_values::white_space_collapse::T as WhiteSpaceCollapse;
use style::context::QuirksMode; use style::context::QuirksMode;
use style::properties::style_structs::InheritedText; use style::properties::style_structs::InheritedText;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::{Clear, Length}; use style::values::computed::Clear;
use style::values::generics::box_::VerticalAlignKeyword; use style::values::generics::box_::VerticalAlignKeyword;
use style::values::generics::font::LineHeight; use style::values::generics::font::LineHeight;
use style::values::specified::box_::BaselineSource; use style::values::specified::box_::BaselineSource;
@ -2298,7 +2298,7 @@ impl<'layout_data> ContentSizesComputation<'layout_data> {
// https://drafts.csswg.org/css-sizing-3/#min-percentage-contribution // https://drafts.csswg.org/css-sizing-3/#min-percentage-contribution
let inline_box = inline_formatting_context.inline_boxes.get(identifier); let inline_box = inline_formatting_context.inline_boxes.get(identifier);
let inline_box = (*inline_box).borrow(); let inline_box = (*inline_box).borrow();
let zero = Length::zero(); let zero = Au::zero();
let padding = inline_box let padding = inline_box
.style .style
.padding(self.containing_block.style.writing_mode) .padding(self.containing_block.style.writing_mode)
@ -2310,14 +2310,14 @@ impl<'layout_data> ContentSizesComputation<'layout_data> {
.style .style
.margin(self.containing_block.style.writing_mode) .margin(self.containing_block.style.writing_mode)
.percentages_relative_to(zero) .percentages_relative_to(zero)
.auto_is(Length::zero); .auto_is(Au::zero);
let pbm = margin + padding + border; let pbm = margin + padding + border;
if inline_box.is_first_fragment { if inline_box.is_first_fragment {
self.add_inline_size(pbm.inline_start.into()); self.add_inline_size(pbm.inline_start);
} }
if inline_box.is_last_fragment { if inline_box.is_last_fragment {
self.ending_inline_pbm_stack.push(pbm.inline_end.into()); self.ending_inline_pbm_stack.push(pbm.inline_end);
} else { } else {
self.ending_inline_pbm_stack.push(Au::zero()); self.ending_inline_pbm_stack.push(Au::zero());
} }

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

@ -14,7 +14,7 @@ use style::computed_values::clear::T as Clear;
use style::computed_values::float::T as Float; use style::computed_values::float::T as Float;
use style::logical_geometry::WritingMode; use style::logical_geometry::WritingMode;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::{Length, LengthOrAuto, Size}; use style::values::computed::{Length, Size};
use style::values::specified::align::AlignFlags; use style::values::specified::align::AlignFlags;
use style::values::specified::{Display, TextAlignKeyword}; use style::values::specified::{Display, TextAlignKeyword};
use style::Zero; use style::Zero;
@ -136,7 +136,7 @@ impl BlockLevelBox {
let min_size = style let min_size = style
.content_min_box_size(containing_block, &pbm) .content_min_box_size(containing_block, &pbm)
.auto_is(Length::zero); .auto_is(Au::zero);
let max_size = style.content_max_box_size(containing_block, &pbm); let max_size = style.content_max_box_size(containing_block, &pbm);
let prefered_size = style.content_box_size(containing_block, &pbm); let prefered_size = style.content_box_size(containing_block, &pbm);
let inline_size = prefered_size let inline_size = prefered_size
@ -144,19 +144,18 @@ impl BlockLevelBox {
.auto_is(|| { .auto_is(|| {
let margin_inline_start = pbm.margin.inline_start.auto_is(Au::zero); let margin_inline_start = pbm.margin.inline_start.auto_is(Au::zero);
let margin_inline_end = pbm.margin.inline_end.auto_is(Au::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Au::zero);
(containing_block.inline_size - containing_block.inline_size -
pbm.padding_border_sums.inline - pbm.padding_border_sums.inline -
margin_inline_start - margin_inline_start -
margin_inline_end) margin_inline_end
.into()
}) })
.clamp_between_extremums(min_size.inline, max_size.inline); .clamp_between_extremums(min_size.inline, max_size.inline);
let block_size = prefered_size let block_size = prefered_size
.block .block
.map(|size| Au::from(size.clamp_between_extremums(min_size.block, max_size.block))); .map(|size| size.clamp_between_extremums(min_size.block, max_size.block));
let containing_block_for_children = ContainingBlock { let containing_block_for_children = ContainingBlock {
inline_size: inline_size.into(), inline_size,
block_size, block_size,
style, style,
}; };
@ -384,7 +383,7 @@ fn calculate_inline_content_size_for_block_level_boxes(
} => { } => {
let size = sizing::outer_inline( let size = sizing::outer_inline(
style, style,
&containing_block, containing_block,
&LogicalVec2::zero(), &LogicalVec2::zero(),
false, /* auto_block_size_stretches_to_containing_block */ false, /* auto_block_size_stretches_to_containing_block */
|containing_block_for_children| { |containing_block_for_children| {
@ -854,7 +853,7 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
sequential_layout_state.as_deref_mut(), sequential_layout_state.as_deref_mut(),
CollapsibleWithParentStartMargin(start_margin_can_collapse_with_children), CollapsibleWithParentStartMargin(start_margin_can_collapse_with_children),
); );
let mut content_block_size = flow_layout.content_block_size; let mut content_block_size: Au = flow_layout.content_block_size.into();
// Update margins. // Update margins.
let mut block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); let mut block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin);
@ -888,13 +887,11 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
.end .end
.adjoin_assign(&collapsible_margins_in_children.end); .adjoin_assign(&collapsible_margins_in_children.end);
} else { } else {
content_block_size += collapsible_margins_in_children.end.solve().into(); content_block_size += collapsible_margins_in_children.end.solve();
} }
let block_size = containing_block_for_children.block_size.auto_is(|| { let block_size = containing_block_for_children.block_size.auto_is(|| {
content_block_size content_block_size.clamp_between_extremums(min_box_size.block, max_box_size.block)
.clamp_between_extremums(min_box_size.block, max_box_size.block)
.into()
}); });
if let Some(ref mut sequential_layout_state) = sequential_layout_state { if let Some(ref mut sequential_layout_state) = sequential_layout_state {
@ -913,7 +910,7 @@ 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.into() + pbm.padding.block_end + pbm.border.block_end, 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 {
@ -995,10 +992,9 @@ impl NonReplacedFormattingContext {
Some(inline_size) => (layout.content_block_size, inline_size), Some(inline_size) => (layout.content_block_size, inline_size),
None => ( None => (
containing_block_for_children.block_size.auto_is(|| { containing_block_for_children.block_size.auto_is(|| {
layout.content_block_size.clamp_between_extremums( layout
min_box_size.block.into(), .content_block_size
max_box_size.block.map(|t| t.into()), .clamp_between_extremums(min_box_size.block, max_box_size.block)
)
}), }),
containing_block_for_children.inline_size, containing_block_for_children.inline_size,
), ),
@ -1054,7 +1050,7 @@ impl NonReplacedFormattingContext {
let min_box_size = self let min_box_size = self
.style .style
.content_min_box_size(containing_block, &pbm) .content_min_box_size(containing_block, &pbm)
.auto_is(Length::zero); .auto_is(Au::zero);
let block_size = box_size.block.map(|block_size| { let block_size = box_size.block.map(|block_size| {
block_size.clamp_between_extremums(min_box_size.block, max_box_size.block) block_size.clamp_between_extremums(min_box_size.block, max_box_size.block)
}); });
@ -1079,15 +1075,15 @@ impl NonReplacedFormattingContext {
let clearance; let clearance;
let mut content_size; let mut content_size;
let mut layout; let mut layout;
if let LengthOrAuto::LengthPercentage(ref inline_size) = box_size.inline { if let AuOrAuto::LengthPercentage(ref inline_size) = box_size.inline {
let inline_size = let inline_size =
inline_size.clamp_between_extremums(min_box_size.inline, max_box_size.inline); inline_size.clamp_between_extremums(min_box_size.inline, max_box_size.inline);
layout = self.layout( layout = self.layout(
layout_context, layout_context,
positioning_context, positioning_context,
&ContainingBlock { &ContainingBlock {
inline_size: inline_size.into(), inline_size,
block_size: block_size.map(|t| t.into()), block_size,
style: &self.style, style: &self.style,
}, },
containing_block, containing_block,
@ -1097,12 +1093,12 @@ impl NonReplacedFormattingContext {
content_size = LogicalVec2 { content_size = LogicalVec2 {
block: layout.content_block_size, block: layout.content_block_size,
inline: inline_size, inline: inline_size,
} };
.into();
} else { } else {
content_size = LogicalVec2 { content_size = LogicalVec2 {
block: block_size.auto_is(|| { block: block_size.auto_is(|| {
Length::from(layout.content_block_size) layout
.content_block_size
.clamp_between_extremums(min_box_size.block, max_box_size.block) .clamp_between_extremums(min_box_size.block, max_box_size.block)
}), }),
inline: inline_size, inline: inline_size,
@ -1118,7 +1114,7 @@ impl NonReplacedFormattingContext {
&collapsed_margin_block_start, &collapsed_margin_block_start,
containing_block, containing_block,
&pbm, &pbm,
content_size + pbm.padding_border_sums.into(), content_size + pbm.padding_border_sums,
&self.style, &self.style,
); );
} else { } else {
@ -1135,8 +1131,8 @@ impl NonReplacedFormattingContext {
// Create a PlacementAmongFloats using the minimum size in all dimensions as the object size. // Create a PlacementAmongFloats using the minimum size in all dimensions as the object size.
let minimum_size_of_block = LogicalVec2 { let minimum_size_of_block = LogicalVec2 {
inline: min_box_size.inline.into(), inline: min_box_size.inline,
block: block_size.auto_is(|| min_box_size.block).into(), block: block_size.auto_is(|| min_box_size.block),
} + pbm.padding_border_sums; } + pbm.padding_border_sums;
let mut placement = PlacementAmongFloats::new( let mut placement = PlacementAmongFloats::new(
&sequential_layout_state.floats, &sequential_layout_state.floats,
@ -1149,8 +1145,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 = let proposed_inline_size = placement_rect.size.inline -
Length::from(placement_rect.size.inline - pbm.padding_border_sums.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.
@ -1161,8 +1158,8 @@ impl NonReplacedFormattingContext {
layout_context, layout_context,
positioning_context, positioning_context,
&ContainingBlock { &ContainingBlock {
inline_size: proposed_inline_size.into(), inline_size: proposed_inline_size,
block_size: block_size.map(|t| t.into()), block_size,
style: &self.style, style: &self.style,
}, },
containing_block, containing_block,
@ -1185,12 +1182,12 @@ impl NonReplacedFormattingContext {
content_size = LogicalVec2 { content_size = LogicalVec2 {
block: layout.content_block_size, block: layout.content_block_size,
inline: inline_size, inline: inline_size,
} };
.into();
} else { } else {
content_size = LogicalVec2 { content_size = LogicalVec2 {
block: block_size.auto_is(|| { block: block_size.auto_is(|| {
Length::from(layout.content_block_size) layout
.content_block_size
.clamp_between_extremums(min_box_size.block, max_box_size.block) .clamp_between_extremums(min_box_size.block, max_box_size.block)
}), }),
inline: proposed_inline_size, inline: proposed_inline_size,
@ -1201,7 +1198,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(
Au::from(content_size.block) + pbm.padding_border_sums.block, content_size.block + pbm.padding_border_sums.block,
&placement_rect.size, &placement_rect.size,
) { ) {
break; break;
@ -1233,8 +1230,8 @@ impl NonReplacedFormattingContext {
sequential_layout_state, sequential_layout_state,
containing_block, containing_block,
&pbm, &pbm,
content_size.inline + pbm.padding_border_sums.inline.into(), content_size.inline + pbm.padding_border_sums.inline,
placement_rect.into(), placement_rect,
); );
} }
@ -1255,9 +1252,7 @@ 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 + clearance.unwrap_or_else(Au::zero),
Au::from(content_size.block) +
clearance.unwrap_or_else(Au::zero),
); );
sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end));
@ -1270,7 +1265,7 @@ impl NonReplacedFormattingContext {
pbm.border.inline_start + pbm.border.inline_start +
effective_margin_inline_start, effective_margin_inline_start,
}, },
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);
@ -1335,7 +1330,7 @@ fn layout_in_flow_replaced_block_level(
&collapsed_margin_block_start, &collapsed_margin_block_start,
containing_block, containing_block,
&pbm, &pbm,
size.into(), size,
style, style,
); );
@ -1399,8 +1394,8 @@ fn layout_in_flow_replaced_block_level(
struct ContainingBlockPaddingAndBorder<'a> { struct ContainingBlockPaddingAndBorder<'a> {
containing_block: ContainingBlock<'a>, containing_block: ContainingBlock<'a>,
pbm: PaddingBorderMargin, pbm: PaddingBorderMargin,
min_box_size: LogicalVec2<Length>, min_box_size: LogicalVec2<Au>,
max_box_size: LogicalVec2<Option<Length>>, max_box_size: LogicalVec2<Option<Au>>,
} }
struct ResolvedMargins { struct ResolvedMargins {
@ -1430,7 +1425,7 @@ fn solve_containing_block_padding_and_border_for_in_flow_box<'a>(
let max_box_size = style.content_max_box_size(containing_block, &pbm); let max_box_size = style.content_max_box_size(containing_block, &pbm);
let min_box_size = style let min_box_size = style
.content_min_box_size(containing_block, &pbm) .content_min_box_size(containing_block, &pbm)
.auto_is(Length::zero); .auto_is(Au::zero);
// https://drafts.csswg.org/css2/#the-width-property // https://drafts.csswg.org/css2/#the-width-property
// https://drafts.csswg.org/css2/visudet.html#min-max-widths // https://drafts.csswg.org/css2/visudet.html#min-max-widths
@ -1439,24 +1434,23 @@ fn solve_containing_block_padding_and_border_for_in_flow_box<'a>(
.auto_is(|| { .auto_is(|| {
let margin_inline_start = pbm.margin.inline_start.auto_is(Au::zero); let margin_inline_start = pbm.margin.inline_start.auto_is(Au::zero);
let margin_inline_end = pbm.margin.inline_end.auto_is(Au::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Au::zero);
(containing_block.inline_size - containing_block.inline_size -
pbm.padding_border_sums.inline - pbm.padding_border_sums.inline -
margin_inline_start - margin_inline_start -
margin_inline_end) margin_inline_end
.into()
}) })
.clamp_between_extremums(min_box_size.inline, max_box_size.inline); .clamp_between_extremums(min_box_size.inline, max_box_size.inline);
// https://drafts.csswg.org/css2/#the-height-property // https://drafts.csswg.org/css2/#the-height-property
// https://drafts.csswg.org/css2/visudet.html#min-max-heights // https://drafts.csswg.org/css2/visudet.html#min-max-heights
let mut block_size = box_size.block; let mut block_size = box_size.block;
if let LengthOrAuto::LengthPercentage(ref mut block_size) = block_size { if let AuOrAuto::LengthPercentage(ref mut block_size) = block_size {
*block_size = block_size.clamp_between_extremums(min_box_size.block, max_box_size.block); *block_size = block_size.clamp_between_extremums(min_box_size.block, max_box_size.block);
} }
let containing_block_for_children = ContainingBlock { let containing_block_for_children = ContainingBlock {
inline_size: inline_size.into(), inline_size,
block_size: block_size.map(|t| t.into()), block_size,
style, style,
}; };
// https://drafts.csswg.org/css-writing-modes/#orthogonal-flows // https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
@ -1585,14 +1579,14 @@ fn solve_inline_margins_avoiding_floats(
sequential_layout_state: &SequentialLayoutState, sequential_layout_state: &SequentialLayoutState,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
inline_size: Length, inline_size: Au,
placement_rect: LogicalRect<Length>, placement_rect: LogicalRect<Au>,
) -> ((Au, Au), Au) { ) -> ((Au, Au), Au) {
let free_space = Au::from(placement_rect.size.inline - inline_size); let free_space = placement_rect.size.inline - inline_size;
debug_assert!(free_space >= Au::zero()); debug_assert!(free_space >= Au::zero());
let cb_info = &sequential_layout_state.floats.containing_block_info; let cb_info = &sequential_layout_state.floats.containing_block_info;
let start_adjustment = Au::from(placement_rect.start_corner.inline) - cb_info.inline_start; let start_adjustment = placement_rect.start_corner.inline - cb_info.inline_start;
let end_adjustment = cb_info.inline_end - placement_rect.max_inline_position().into(); let end_adjustment = cb_info.inline_end - placement_rect.max_inline_position();
let mut justification = Au::zero(); let mut justification = Au::zero();
let inline_margins = match (pbm.margin.inline_start, pbm.margin.inline_end) { let inline_margins = match (pbm.margin.inline_start, pbm.margin.inline_end) {
(AuOrAuto::Auto, AuOrAuto::Auto) => { (AuOrAuto::Auto, AuOrAuto::Auto) => {
@ -1625,7 +1619,7 @@ fn solve_clearance_and_inline_margins_avoiding_floats(
block_start_margin: &CollapsedMargin, block_start_margin: &CollapsedMargin,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
size: LogicalVec2<Length>, size: LogicalVec2<Au>,
style: &Arc<ComputedValues>, style: &Arc<ComputedValues>,
) -> (Option<Au>, (Au, Au), Au) { ) -> (Option<Au>, (Au, Au), Au) {
let (clearance, placement_rect) = sequential_layout_state let (clearance, placement_rect) = sequential_layout_state
@ -1633,14 +1627,14 @@ fn solve_clearance_and_inline_margins_avoiding_floats(
style.get_box().clear, style.get_box().clear,
block_start_margin, block_start_margin,
pbm, pbm,
size.into(), size,
); );
let (inline_margins, effective_margin_inline_start) = solve_inline_margins_avoiding_floats( let (inline_margins, effective_margin_inline_start) = solve_inline_margins_avoiding_floats(
sequential_layout_state, sequential_layout_state,
containing_block, containing_block,
pbm, pbm,
size.inline, size.inline,
placement_rect.into(), placement_rect,
); );
(clearance, inline_margins, effective_margin_inline_start) (clearance, inline_margins, effective_margin_inline_start)
} }

2
components/layout_2020/formatting_contexts.rs
View file

@ -287,7 +287,7 @@ impl NonReplacedFormattingContext {
.insert(( .insert((
containing_block_for_children.size.block, containing_block_for_children.size.block,
self.contents self.contents
.inline_content_sizes(layout_context, &containing_block_for_children), .inline_content_sizes(layout_context, containing_block_for_children),
)) ))
.1 .1
} }

49
components/layout_2020/fragment_tree/box_fragment.rs
View file

@ -10,7 +10,7 @@ use style::computed_values::overflow_x::T as ComputedOverflow;
use style::computed_values::position::T as ComputedPosition; use style::computed_values::position::T as ComputedPosition;
use style::logical_geometry::WritingMode; use style::logical_geometry::WritingMode;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::{CSSPixelLength, Length, LengthPercentage, LengthPercentageOrAuto}; use style::values::computed::{LengthPercentage, LengthPercentageOrAuto};
use style::Zero; use style::Zero;
use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment}; use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment};
@ -304,7 +304,7 @@ impl BoxFragment {
return resolved_sticky_insets; return resolved_sticky_insets;
} }
let convert_to_length_or_auto = |sides: PhysicalSides<Au>| { let convert_to_au_or_auto = |sides: PhysicalSides<Au>| {
PhysicalSides::new( PhysicalSides::new(
AuOrAuto::LengthPercentage(sides.top), AuOrAuto::LengthPercentage(sides.top),
AuOrAuto::LengthPercentage(sides.right), AuOrAuto::LengthPercentage(sides.right),
@ -321,29 +321,23 @@ impl BoxFragment {
// https://drafts.csswg.org/cssom/#resolved-values // https://drafts.csswg.org/cssom/#resolved-values
let insets = self.style.get_position(); let insets = self.style.get_position();
if position == ComputedPosition::Relative { if position == ComputedPosition::Relative {
let get_resolved_axis = let get_resolved_axis = |start: &LengthPercentageOrAuto,
|start: &LengthPercentageOrAuto, end: &LengthPercentageOrAuto,
end: &LengthPercentageOrAuto, container_length: Au| {
container_length: CSSPixelLength| { let start = start.map(|value| value.to_used_value(container_length));
let start = start.map(|v| v.percentage_relative_to(container_length)); let end = end.map(|value| value.to_used_value(container_length));
let end = end.map(|v| v.percentage_relative_to(container_length)); match (start.non_auto(), end.non_auto()) {
match (start.non_auto(), end.non_auto()) { (None, None) => (Au::zero(), Au::zero()),
(None, None) => (Length::zero(), Length::zero()), (None, Some(end)) => (-end, end),
(None, Some(end)) => (-end, end), (Some(start), None) => (start, -start),
(Some(start), None) => (start, -start), // This is the overconstrained case, for which the resolved insets will
// This is the overconstrained case, for which the resolved insets will // simply be the computed insets.
// simply be the computed insets. (Some(start), Some(end)) => (start, end),
(Some(start), Some(end)) => (start, end), }
} };
}; let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width);
let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width.into()); let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height);
let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height.into()); return convert_to_au_or_auto(PhysicalSides::new(top, right, bottom, left));
return convert_to_length_or_auto(PhysicalSides::new(
top.into(),
right.into(),
bottom.into(),
left.into(),
));
} }
debug_assert!( debug_assert!(
@ -353,8 +347,7 @@ impl BoxFragment {
let resolve = |value: &LengthPercentageOrAuto, container_length: Au| -> Au { let resolve = |value: &LengthPercentageOrAuto, container_length: Au| -> Au {
value value
.auto_is(LengthPercentage::zero) .auto_is(LengthPercentage::zero)
.percentage_relative_to(container_length.into()) .to_used_value(container_length)
.into()
}; };
let (top, bottom) = if self.overconstrained.height { let (top, bottom) = if self.overconstrained.height {
@ -374,6 +367,6 @@ impl BoxFragment {
(content_rect.origin.x, cb_width - content_rect.max_x()) (content_rect.origin.x, cb_width - content_rect.max_x())
}; };
convert_to_length_or_auto(PhysicalSides::new(top, right, bottom, left)) convert_to_au_or_auto(PhysicalSides::new(top, right, bottom, left))
} }
} }

67
components/layout_2020/geom.rs
View file

@ -154,14 +154,20 @@ impl LogicalVec2<LengthPercentageOrAuto<'_>> {
pub(crate) fn percentages_relative_to( pub(crate) fn percentages_relative_to(
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
LogicalVec2 { LogicalVec2 {
inline: self inline: self
.inline .inline
.percentage_relative_to(containing_block.inline_size.into()), .map(|value| value.to_used_value(containing_block.inline_size)),
block: self.block.maybe_percentage_relative_to( block: {
containing_block.block_size.map(|t| t.into()).non_auto(), let containing_block_block_size =
), containing_block.block_size.non_auto().map(Into::into);
self.block
.non_auto()
.and_then(|value| value.maybe_to_used_value(containing_block_block_size))
.map(|value| AuOrAuto::LengthPercentage(value))
.unwrap_or(AuOrAuto::Auto)
},
} }
} }
} }
@ -169,11 +175,11 @@ impl LogicalVec2<LengthPercentageOrAuto<'_>> {
impl LogicalVec2<LengthPercentageOrAuto<'_>> { impl LogicalVec2<LengthPercentageOrAuto<'_>> {
pub(crate) fn percentages_relative_to_basis( pub(crate) fn percentages_relative_to_basis(
&self, &self,
basis: &LogicalVec2<Length>, basis: &LogicalVec2<Au>,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
LogicalVec2 { LogicalVec2 {
inline: self.inline.percentage_relative_to(basis.inline), inline: self.inline.map(|value| value.to_used_value(basis.inline)),
block: self.block.percentage_relative_to(basis.block), block: self.block.map(|value| value.to_used_value(basis.block)),
} }
} }
} }
@ -181,11 +187,22 @@ impl LogicalVec2<LengthPercentageOrAuto<'_>> {
impl LogicalVec2<LengthPercentageOrAuto<'_>> { impl LogicalVec2<LengthPercentageOrAuto<'_>> {
pub(crate) fn maybe_percentages_relative_to_basis( pub(crate) fn maybe_percentages_relative_to_basis(
&self, &self,
basis: &LogicalVec2<Option<Length>>, basis: &LogicalVec2<Option<Au>>,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
let basis = basis.map(|value| value.map(Into::into));
LogicalVec2 { LogicalVec2 {
inline: self.inline.maybe_percentage_relative_to(basis.inline), inline: self
block: self.block.maybe_percentage_relative_to(basis.block), .inline
.non_auto()
.and_then(|value| value.maybe_to_used_value(basis.inline))
.map(|value| AuOrAuto::LengthPercentage(value))
.unwrap_or(AuOrAuto::Auto),
block: self
.block
.non_auto()
.and_then(|value| value.maybe_to_used_value(basis.block))
.map(|value| AuOrAuto::LengthPercentage(value))
.unwrap_or(AuOrAuto::Auto),
} }
} }
} }
@ -194,15 +211,13 @@ impl LogicalVec2<Option<&'_ LengthPercentage>> {
pub(crate) fn percentages_relative_to( pub(crate) fn percentages_relative_to(
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
) -> LogicalVec2<Option<Length>> { ) -> LogicalVec2<Option<Au>> {
LogicalVec2 { LogicalVec2 {
inline: self inline: self
.inline .inline
.map(|lp| lp.percentage_relative_to(containing_block.inline_size.into())), .map(|lp| lp.to_used_value(containing_block.inline_size)),
block: self.block.and_then(|lp| { block: self.block.and_then(|lp| {
lp.maybe_percentage_relative_to( lp.maybe_to_used_value(containing_block.block_size.map(Into::into).non_auto())
containing_block.block_size.map(|t| t.into()).non_auto(),
)
}), }),
} }
} }
@ -211,15 +226,15 @@ impl LogicalVec2<Option<&'_ LengthPercentage>> {
impl LogicalVec2<Option<&'_ LengthPercentage>> { impl LogicalVec2<Option<&'_ LengthPercentage>> {
pub(crate) fn maybe_percentages_relative_to_basis( pub(crate) fn maybe_percentages_relative_to_basis(
&self, &self,
basis: &LogicalVec2<Option<Length>>, basis: &LogicalVec2<Option<Au>>,
) -> LogicalVec2<Option<Length>> { ) -> LogicalVec2<Option<Au>> {
LogicalVec2 { LogicalVec2 {
inline: self inline: self
.inline .inline
.and_then(|v| v.maybe_percentage_relative_to(basis.inline)), .and_then(|v| v.maybe_to_used_value(basis.inline.map(Into::into))),
block: self block: self
.block .block
.and_then(|v| v.maybe_percentage_relative_to(basis.block)), .and_then(|v| v.maybe_to_used_value(basis.block.map(Into::into))),
} }
} }
} }
@ -389,14 +404,14 @@ impl<T: Copy> LogicalSides<T> {
} }
impl LogicalSides<&'_ LengthPercentage> { impl LogicalSides<&'_ LengthPercentage> {
pub fn percentages_relative_to(&self, basis: Length) -> LogicalSides<Length> { pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<Au> {
self.map(|s| s.percentage_relative_to(basis)) self.map(|value| value.to_used_value(basis))
} }
} }
impl LogicalSides<LengthPercentageOrAuto<'_>> { impl LogicalSides<LengthPercentageOrAuto<'_>> {
pub fn percentages_relative_to(&self, basis: Length) -> LogicalSides<LengthOrAuto> { pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<AuOrAuto> {
self.map(|s| s.percentage_relative_to(basis)) self.map(|value| value.map(|value| value.to_used_value(basis)))
} }
} }

2
components/layout_2020/lib.rs
View file

@ -67,7 +67,7 @@ impl<'a> IndefiniteContainingBlock<'a> {
auto_minimum: &LogicalVec2<Au>, auto_minimum: &LogicalVec2<Au>,
) -> Self { ) -> Self {
let (content_box_size, content_min_size, content_max_size, _) = let (content_box_size, content_min_size, content_max_size, _) =
style.content_box_sizes_and_padding_border_margin(&self); style.content_box_sizes_and_padding_border_margin(self);
let block_size = content_box_size.block.map(|v| { let block_size = content_box_size.block.map(|v| {
v.clamp_between_extremums( v.clamp_between_extremums(
content_min_size.block.auto_is(|| auto_minimum.block), content_min_size.block.auto_is(|| auto_minimum.block),

63
components/layout_2020/positioned.rs
View file

@ -21,8 +21,8 @@ use crate::fragment_tree::{
BoxFragment, CollapsedBlockMargins, Fragment, FragmentFlags, HoistedSharedFragment, BoxFragment, CollapsedBlockMargins, Fragment, FragmentFlags, HoistedSharedFragment,
}; };
use crate::geom::{ use crate::geom::{
AuOrAuto, LengthOrAuto, LengthPercentageOrAuto, LogicalRect, LogicalSides, LogicalVec2, AuOrAuto, LengthPercentageOrAuto, LogicalRect, LogicalSides, LogicalVec2, PhysicalPoint,
PhysicalPoint, PhysicalRect, PhysicalVec, ToLogical, PhysicalRect, PhysicalVec, ToLogical,
}; };
use crate::style_ext::{ComputedValuesExt, DisplayInside}; use crate::style_ext::{ComputedValuesExt, DisplayInside};
use crate::{ContainingBlock, DefiniteContainingBlock, IndefiniteContainingBlock}; use crate::{ContainingBlock, DefiniteContainingBlock, IndefiniteContainingBlock};
@ -466,8 +466,8 @@ impl HoistedAbsolutelyPositionedBox {
&pbm, &pbm,
); );
LogicalVec2 { LogicalVec2 {
inline: LengthOrAuto::LengthPercentage(used_size.inline.into()), inline: AuOrAuto::LengthPercentage(used_size.inline),
block: LengthOrAuto::LengthPercentage(used_size.block.into()), block: AuOrAuto::LengthPercentage(used_size.block),
} }
}, },
IndependentFormattingContext::NonReplaced(..) => { IndependentFormattingContext::NonReplaced(..) => {
@ -532,10 +532,8 @@ impl HoistedAbsolutelyPositionedBox {
block: block_axis_solver.is_overconstrained_for_size(computed_size.block), block: block_axis_solver.is_overconstrained_for_size(computed_size.block),
}; };
let mut inline_axis = let mut inline_axis = inline_axis_solver.solve_for_size(computed_size.inline);
inline_axis_solver.solve_for_size(computed_size.inline.map(|t| t.into())); let mut block_axis = block_axis_solver.solve_for_size(computed_size.block);
let mut block_axis =
block_axis_solver.solve_for_size(computed_size.block.map(|t| t.into()));
let mut positioning_context = let mut positioning_context =
PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap(); PositioningContext::new_for_style(absolutely_positioned_box.context.style()).unwrap();
@ -547,7 +545,7 @@ impl HoistedAbsolutelyPositionedBox {
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-width // https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
// https://drafts.csswg.org/css2/visudet.html#abs-replaced-height // https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
let style = &replaced.style; let style = &replaced.style;
content_size = computed_size.auto_is(|| unreachable!()).into(); content_size = computed_size.auto_is(|| unreachable!());
fragments = replaced.contents.make_fragments( fragments = replaced.contents.make_fragments(
style, style,
content_size.to_physical_size(containing_block_writing_mode), content_size.to_physical_size(containing_block_writing_mode),
@ -854,38 +852,27 @@ impl<'a> AbsoluteAxisSolver<'a> {
margin_end: self.computed_margin_end.auto_is(Au::zero), margin_end: self.computed_margin_end.auto_is(Au::zero),
}, },
(Some(start), None) => AxisResult { (Some(start), None) => AxisResult {
anchor: Anchor::Start( anchor: Anchor::Start(start.to_used_value(self.containing_size)),
start
.percentage_relative_to(self.containing_size.into())
.into(),
),
size: computed_size, size: computed_size,
margin_start: self.computed_margin_start.auto_is(Au::zero), margin_start: self.computed_margin_start.auto_is(Au::zero),
margin_end: self.computed_margin_end.auto_is(Au::zero), margin_end: self.computed_margin_end.auto_is(Au::zero),
}, },
(None, Some(end)) => AxisResult { (None, Some(end)) => AxisResult {
anchor: Anchor::End( anchor: Anchor::End(end.to_used_value(self.containing_size)),
end.percentage_relative_to(self.containing_size.into())
.into(),
),
size: computed_size, size: computed_size,
margin_start: self.computed_margin_start.auto_is(Au::zero), margin_start: self.computed_margin_start.auto_is(Au::zero),
margin_end: self.computed_margin_end.auto_is(Au::zero), margin_end: self.computed_margin_end.auto_is(Au::zero),
}, },
(Some(start), Some(end)) => { (Some(start), Some(end)) => {
let start = start.percentage_relative_to(self.containing_size.into()); let start = start.to_used_value(self.containing_size);
let end = end.percentage_relative_to(self.containing_size.into()); let end = end.to_used_value(self.containing_size);
let margin_start; let margin_start;
let margin_end; let margin_end;
let used_size; let used_size;
if let AuOrAuto::LengthPercentage(s) = computed_size { if let AuOrAuto::LengthPercentage(s) = computed_size {
used_size = s; used_size = s;
let margins = self.containing_size - let margins = self.containing_size - start - end - self.padding_border_sum - s;
start.into() -
end.into() -
self.padding_border_sum -
s;
match (self.computed_margin_start, self.computed_margin_end) { match (self.computed_margin_start, self.computed_margin_end) {
(AuOrAuto::Auto, AuOrAuto::Auto) => { (AuOrAuto::Auto, AuOrAuto::Auto) => {
if self.avoid_negative_margin_start && margins < Au::zero() { if self.avoid_negative_margin_start && margins < Au::zero() {
@ -916,14 +903,14 @@ impl<'a> AbsoluteAxisSolver<'a> {
// This may be negative, but the caller will later effectively // This may be negative, but the caller will later effectively
// clamp it to ‘min-inline-size’ or ‘min-block-size’. // clamp it to ‘min-inline-size’ or ‘min-block-size’.
used_size = self.containing_size - used_size = self.containing_size -
start.into() - start -
end.into() - end -
self.padding_border_sum - self.padding_border_sum -
margin_start - margin_start -
margin_end; margin_end;
}; };
AxisResult { AxisResult {
anchor: Anchor::Start(start.into()), anchor: Anchor::Start(start),
size: AuOrAuto::LengthPercentage(used_size), size: AuOrAuto::LengthPercentage(used_size),
margin_start, margin_start,
margin_end, margin_end,
@ -932,7 +919,7 @@ impl<'a> AbsoluteAxisSolver<'a> {
} }
} }
fn is_overconstrained_for_size(&self, computed_size: LengthOrAuto) -> bool { fn is_overconstrained_for_size(&self, computed_size: AuOrAuto) -> bool {
!computed_size.is_auto() && !computed_size.is_auto() &&
self.box_offsets.both_specified() && self.box_offsets.both_specified() &&
!self.computed_margin_start.is_auto() && !self.computed_margin_start.is_auto() &&
@ -946,12 +933,12 @@ impl<'a> AbsoluteAxisSolver<'a> {
) { ) {
(None, None) => self.static_position_rect_axis, (None, None) => self.static_position_rect_axis,
(Some(start), Some(end)) => { (Some(start), Some(end)) => {
let start = start.percentage_relative_to(self.containing_size.into()); let start = start.to_used_value(self.containing_size);
let end = end.percentage_relative_to(self.containing_size.into()); let end = end.to_used_value(self.containing_size);
RectAxis { RectAxis {
origin: start.into(), origin: start,
length: self.containing_size - (end + start).into(), length: self.containing_size - (end + start),
} }
}, },
_ => return None, _ => return None,
@ -1021,11 +1008,11 @@ pub(crate) fn relative_adjustement(
let box_offsets = style let box_offsets = style
.box_offsets(containing_block) .box_offsets(containing_block)
.map_inline_and_block_axes( .map_inline_and_block_axes(
|v| v.percentage_relative_to(cbis.into()).map(Au::from), |value| value.map(|value| value.to_used_value(cbis)),
|v| match cbbs.non_auto() { |value| match cbbs.non_auto() {
Some(cbbs) => v.percentage_relative_to(cbbs.into()).map(Au::from), Some(cbbs) => value.map(|value| value.to_used_value(cbbs)),
None => match v.non_auto().and_then(|v| v.to_length()) { None => match value.non_auto().and_then(|value| value.to_length()) {
Some(v) => AuOrAuto::LengthPercentage(v.into()), Some(value) => AuOrAuto::LengthPercentage(value.into()),
None => AuOrAuto::Auto, None => AuOrAuto::Auto,
}, },
}, },

7
components/layout_2020/replaced.rs
View file

@ -371,14 +371,11 @@ impl ReplacedContent {
// We need to clamp to zero here to obtain the proper aspect // We need to clamp to zero here to obtain the proper aspect
// ratio when box-sizing is border-box and the inner box size // ratio when box-sizing is border-box and the inner box size
// would otherwise be negative. // would otherwise be negative.
.map(|v| v.map(|v| Au::from(v).max(Au::zero()))); .map(|value| value.map(|value| value.max(Au::zero())));
let min_box_size = style let min_box_size = style
.content_min_box_size(containing_block, pbm) .content_min_box_size(containing_block, pbm)
.map(|v| v.map(Au::from))
.auto_is(Au::zero); .auto_is(Au::zero);
let max_box_size = style let max_box_size = style.content_max_box_size(containing_block, pbm);
.content_max_box_size(containing_block, pbm)
.map(|v| v.map(Au::from));
self.used_size_as_if_inline_element_from_content_box_sizes( self.used_size_as_if_inline_element_from_content_box_sizes(
containing_block, containing_block,
style, style,

110
components/layout_2020/style_ext.rs
View file

@ -15,9 +15,7 @@ use style::properties::longhands::column_span::computed_value::T as ColumnSpan;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::basic_shape::ClipPath; use style::values::computed::basic_shape::ClipPath;
use style::values::computed::image::Image as ComputedImageLayer; use style::values::computed::image::Image as ComputedImageLayer;
use style::values::computed::{ use style::values::computed::{AlignItems, LengthPercentage, NonNegativeLengthPercentage, Size};
AlignItems, Length, LengthPercentage, NonNegativeLengthPercentage, Size,
};
use style::values::generics::box_::Perspective; use style::values::generics::box_::Perspective;
use style::values::generics::length::MaxSize; use style::values::generics::length::MaxSize;
use style::values::generics::position::{GenericAspectRatio, PreferredRatio}; use style::values::generics::position::{GenericAspectRatio, PreferredRatio};
@ -30,8 +28,7 @@ use webrender_api as wr;
use crate::dom_traversal::Contents; use crate::dom_traversal::Contents;
use crate::fragment_tree::FragmentFlags; use crate::fragment_tree::FragmentFlags;
use crate::geom::{ use crate::geom::{
AuOrAuto, LengthOrAuto, LengthPercentageOrAuto, LogicalSides, LogicalVec2, PhysicalSides, AuOrAuto, LengthPercentageOrAuto, LogicalSides, LogicalVec2, PhysicalSides, PhysicalSize,
PhysicalSize,
}; };
use crate::{ContainingBlock, IndefiniteContainingBlock}; use crate::{ContainingBlock, IndefiniteContainingBlock};
@ -210,32 +207,32 @@ pub(crate) trait ComputedValuesExt {
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>; ) -> LogicalVec2<AuOrAuto>;
fn content_box_size_for_box_size( fn content_box_size_for_box_size(
&self, &self,
box_size: LogicalVec2<LengthOrAuto>, box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>; ) -> LogicalVec2<AuOrAuto>;
fn content_min_box_size( fn content_min_box_size(
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>; ) -> LogicalVec2<AuOrAuto>;
fn content_min_box_size_for_min_size( fn content_min_box_size_for_min_size(
&self, &self,
box_size: LogicalVec2<LengthOrAuto>, box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>; ) -> LogicalVec2<AuOrAuto>;
fn content_max_box_size( fn content_max_box_size(
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>>; ) -> LogicalVec2<Option<Au>>;
fn content_max_box_size_for_max_size( fn content_max_box_size_for_max_size(
&self, &self,
box_size: LogicalVec2<Option<Length>>, box_size: LogicalVec2<Option<Au>>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>>; ) -> LogicalVec2<Option<Au>>;
fn content_box_sizes_and_padding_border_margin( fn content_box_sizes_and_padding_border_margin(
&self, &self,
containing_block: &IndefiniteContainingBlock, containing_block: &IndefiniteContainingBlock,
@ -259,7 +256,7 @@ pub(crate) trait ComputedValuesExt {
&self, &self,
containing_block_writing_mode: WritingMode, containing_block_writing_mode: WritingMode,
) -> LogicalSides<&LengthPercentage>; ) -> LogicalSides<&LengthPercentage>;
fn border_width(&self, containing_block_writing_mode: WritingMode) -> LogicalSides<Length>; fn border_width(&self, containing_block_writing_mode: WritingMode) -> LogicalSides<Au>;
fn margin( fn margin(
&self, &self,
containing_block_writing_mode: WritingMode, containing_block_writing_mode: WritingMode,
@ -363,7 +360,7 @@ impl ComputedValuesExt for ComputedValues {
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
let box_size = self let box_size = self
.box_size(containing_block.effective_writing_mode()) .box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block); .percentages_relative_to(containing_block);
@ -372,9 +369,9 @@ impl ComputedValuesExt for ComputedValues {
fn content_box_size_for_box_size( fn content_box_size_for_box_size(
&self, &self,
box_size: LogicalVec2<LengthOrAuto>, box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
match self.get_position().box_sizing { match self.get_position().box_sizing {
BoxSizing::ContentBox => box_size, BoxSizing::ContentBox => box_size,
BoxSizing::BorderBox => LogicalVec2 { BoxSizing::BorderBox => LogicalVec2 {
@ -382,10 +379,10 @@ impl ComputedValuesExt for ComputedValues {
// which is clamped to zero. // which is clamped to zero.
inline: box_size inline: box_size
.inline .inline
.map(|i| i - pbm.padding_border_sums.inline.into()), .map(|value| value - pbm.padding_border_sums.inline),
block: box_size block: box_size
.block .block
.map(|b| b - pbm.padding_border_sums.block.into()), .map(|value| value - pbm.padding_border_sums.block),
}, },
} }
} }
@ -394,7 +391,7 @@ impl ComputedValuesExt for ComputedValues {
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
let box_size = self let box_size = self
.min_box_size(containing_block.effective_writing_mode()) .min_box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block); .percentages_relative_to(containing_block);
@ -403,19 +400,19 @@ impl ComputedValuesExt for ComputedValues {
fn content_min_box_size_for_min_size( fn content_min_box_size_for_min_size(
&self, &self,
min_box_size: LogicalVec2<LengthOrAuto>, min_box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> { ) -> LogicalVec2<AuOrAuto> {
match self.get_position().box_sizing { match self.get_position().box_sizing {
BoxSizing::ContentBox => min_box_size, BoxSizing::ContentBox => min_box_size,
BoxSizing::BorderBox => LogicalVec2 { BoxSizing::BorderBox => LogicalVec2 {
// 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.into()).max(Length::zero())), .map(|value| (value - pbm.padding_border_sums.inline).max(Au::zero())),
block: min_box_size block: min_box_size
.block .block
.map(|b| (b - pbm.padding_border_sums.block.into()).max(Length::zero())), .map(|value| (value - pbm.padding_border_sums.block).max(Au::zero())),
}, },
} }
} }
@ -424,7 +421,7 @@ impl ComputedValuesExt for ComputedValues {
&self, &self,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>> { ) -> LogicalVec2<Option<Au>> {
let max_box_size = self let max_box_size = self
.max_box_size(containing_block.effective_writing_mode()) .max_box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block); .percentages_relative_to(containing_block);
@ -434,9 +431,9 @@ impl ComputedValuesExt for ComputedValues {
fn content_max_box_size_for_max_size( fn content_max_box_size_for_max_size(
&self, &self,
max_box_size: LogicalVec2<Option<Length>>, max_box_size: LogicalVec2<Option<Au>>,
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>> { ) -> LogicalVec2<Option<Au>> {
match self.get_position().box_sizing { match self.get_position().box_sizing {
BoxSizing::ContentBox => max_box_size, BoxSizing::ContentBox => max_box_size,
BoxSizing::BorderBox => { BoxSizing::BorderBox => {
@ -445,10 +442,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.into()), .map(|value| value - pbm.padding_border_sums.inline),
block: max_box_size block: max_box_size
.block .block
.map(|b| b - pbm.padding_border_sums.block.into()), .map(|value| value - pbm.padding_border_sums.block),
} }
}, },
} }
@ -468,9 +465,9 @@ impl ComputedValuesExt for ComputedValues {
// indefinite percentages, we treat the entire value as the initial value of the property. // indefinite percentages, we treat the entire value as the initial value of the property.
// However, for min size properties, as well as for margins and paddings, // However, for min size properties, as well as for margins and paddings,
// we instead resolve indefinite percentages against zero. // we instead resolve indefinite percentages against zero.
let containing_block_size = containing_block.size.map(|v| v.non_auto().map(Into::into)); let containing_block_size = containing_block.size.map(|value| value.non_auto());
let containing_block_size_auto_is_zero = let containing_block_size_auto_is_zero =
containing_block_size.map(|v| v.unwrap_or_else(Length::zero)); containing_block_size.map(|value| value.unwrap_or_else(Au::zero));
let writing_mode = self.writing_mode; let writing_mode = self.writing_mode;
let pbm = self.padding_border_margin_with_writing_mode_and_containing_block_inline_size( let pbm = self.padding_border_margin_with_writing_mode_and_containing_block_inline_size(
writing_mode, writing_mode,
@ -501,19 +498,19 @@ impl ComputedValuesExt for ComputedValues {
let cbis = containing_block.inline_size; let cbis = containing_block.inline_size;
let padding = self let padding = self
.padding(containing_block.effective_writing_mode()) .padding(containing_block.effective_writing_mode())
.percentages_relative_to(cbis.into()); .percentages_relative_to(cbis);
let border = self.border_width(containing_block.effective_writing_mode()); let border = self.border_width(containing_block.effective_writing_mode());
let margin = self let margin = self
.margin(containing_block.effective_writing_mode()) .margin(containing_block.effective_writing_mode())
.percentages_relative_to(cbis.into()); .percentages_relative_to(cbis);
PaddingBorderMargin { PaddingBorderMargin {
padding_border_sums: LogicalVec2 { padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(), inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()).into(), block: (padding.block_sum() + border.block_sum()),
}, },
padding: padding.into(), padding,
border: border.into(), border,
margin: margin.map(|t| t.map(|m| m.into())), margin,
} }
} }
@ -523,19 +520,19 @@ impl ComputedValuesExt for ComputedValues {
) -> PaddingBorderMargin { ) -> PaddingBorderMargin {
let padding = self let padding = self
.padding(writing_mode) .padding(writing_mode)
.percentages_relative_to(Length::zero()); .percentages_relative_to(Au::zero());
let border = self.border_width(writing_mode); let border = self.border_width(writing_mode);
let margin = self let margin = self
.margin(writing_mode) .margin(writing_mode)
.percentages_relative_to(Length::zero()); .percentages_relative_to(Au::zero());
PaddingBorderMargin { PaddingBorderMargin {
padding_border_sums: LogicalVec2 { padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(), inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()).into(), block: (padding.block_sum() + border.block_sum()),
}, },
padding: padding.into(), padding,
border: border.into(), border,
margin: margin.map(|t| t.map(|m| m.into())), margin,
} }
} }
@ -544,7 +541,6 @@ impl ComputedValuesExt for ComputedValues {
writing_mode: WritingMode, writing_mode: WritingMode,
containing_block_inline_size: Au, containing_block_inline_size: Au,
) -> PaddingBorderMargin { ) -> PaddingBorderMargin {
let containing_block_inline_size = containing_block_inline_size.into();
let padding = self let padding = self
.padding(writing_mode) .padding(writing_mode)
.percentages_relative_to(containing_block_inline_size); .percentages_relative_to(containing_block_inline_size);
@ -554,12 +550,12 @@ impl ComputedValuesExt for ComputedValues {
.percentages_relative_to(containing_block_inline_size); .percentages_relative_to(containing_block_inline_size);
PaddingBorderMargin { PaddingBorderMargin {
padding_border_sums: LogicalVec2 { padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(), inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()).into(), block: (padding.block_sum() + border.block_sum()),
}, },
padding: padding.into(), padding,
border: border.into(), border,
margin: margin.map(|margin_side| margin_side.map(Into::into)), margin,
} }
} }
@ -579,14 +575,14 @@ impl ComputedValuesExt for ComputedValues {
) )
} }
fn border_width(&self, containing_block_writing_mode: WritingMode) -> LogicalSides<Length> { fn border_width(&self, containing_block_writing_mode: WritingMode) -> LogicalSides<Au> {
let border = self.get_border(); let border = self.get_border();
LogicalSides::from_physical( LogicalSides::from_physical(
&PhysicalSides::new( &PhysicalSides::new(
border.border_top_width.into(), border.border_top_width,
border.border_right_width.into(), border.border_right_width,
border.border_bottom_width.into(), border.border_bottom_width,
border.border_left_width.into(), border.border_left_width,
), ),
containing_block_writing_mode, containing_block_writing_mode,
) )

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

@ -15,7 +15,7 @@ use style::computed_values::empty_cells::T as EmptyCells;
use style::computed_values::visibility::T as Visibility; use style::computed_values::visibility::T as Visibility;
use style::logical_geometry::WritingMode; use style::logical_geometry::WritingMode;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use style::values::computed::{Length, LengthPercentage as ComputedLengthPercentage, Percentage}; use style::values::computed::{LengthPercentage as ComputedLengthPercentage, Percentage};
use style::values::generics::box_::{GenericVerticalAlign as VerticalAlign, VerticalAlignKeyword}; use style::values::generics::box_::{GenericVerticalAlign as VerticalAlign, VerticalAlignKeyword};
use style::values::generics::length::GenericLengthPercentageOrAuto::{Auto, LengthPercentage}; use style::values::generics::length::GenericLengthPercentageOrAuto::{Auto, LengthPercentage};
use style::Zero; use style::Zero;
@ -185,7 +185,7 @@ impl<'a> TableLayout<'a> {
let padding = cell let padding = cell
.style .style
.padding(writing_mode) .padding(writing_mode)
.percentages_relative_to(Length::zero()); .percentages_relative_to(Au::zero());
let border = self let border = self
.get_collapsed_borders_for_cell( .get_collapsed_borders_for_cell(
@ -195,8 +195,8 @@ impl<'a> TableLayout<'a> {
.unwrap_or_else(|| cell.style.border_width(writing_mode)); .unwrap_or_else(|| cell.style.border_width(writing_mode));
let padding_border_sums = LogicalVec2 { let padding_border_sums = LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(), inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()).into(), block: (padding.block_sum() + border.block_sum()),
}; };
let (size, min_size, max_size) = let (size, min_size, max_size) =
@ -681,18 +681,17 @@ impl<'a> TableLayout<'a> {
let padding = context let padding = context
.style .style
.padding(writing_mode) .padding(writing_mode)
.percentages_relative_to(Length::zero()); .percentages_relative_to(Au::zero());
let border = context.style.border_width(writing_mode); let border = context.style.border_width(writing_mode);
let margin = context let margin = context
.style .style
.margin(writing_mode) .margin(writing_mode)
.percentages_relative_to(Length::zero()) .percentages_relative_to(Au::zero())
.auto_is(Length::zero); .auto_is(Au::zero);
let padding_border_sums = LogicalVec2 { let padding_border_sums = LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum() + margin.inline_sum()) inline: (padding.inline_sum() + border.inline_sum() + margin.inline_sum()),
.into(), block: (padding.block_sum() + border.block_sum() + margin.block_sum()),
block: (padding.block_sum() + border.block_sum() + margin.block_sum()).into(),
}; };
let (size, min_size, max_size) = let (size, min_size, max_size) =
@ -752,8 +751,7 @@ impl<'a> TableLayout<'a> {
let min_width: Au = style let min_width: Au = style
.content_min_box_size(containing_block_for_table, &self.pbm) .content_min_box_size(containing_block_for_table, &self.pbm)
.inline .inline
.auto_is(Length::zero) .auto_is(Au::zero);
.into();
resolved_table_width resolved_table_width
.clamp(grid_min_max.min_content, grid_min_max.max_content) .clamp(grid_min_max.min_content, grid_min_max.max_content)
.max(min_width) .max(min_width)
@ -1140,14 +1138,12 @@ impl<'a> TableLayout<'a> {
cell.style.border_width( cell.style.border_width(
containing_block_for_table.effective_writing_mode(), containing_block_for_table.effective_writing_mode(),
) )
}) });
.into();
let padding: LogicalSides<Au> = cell let padding: LogicalSides<Au> = cell
.style .style
.padding(containing_block_for_table.effective_writing_mode()) .padding(containing_block_for_table.effective_writing_mode())
.percentages_relative_to(self.basis_for_cell_padding_percentage.into()) .percentages_relative_to(self.basis_for_cell_padding_percentage);
.into();
let inline_border_padding_sum = border.inline_sum() + padding.inline_sum(); let inline_border_padding_sum = border.inline_sum() + padding.inline_sum();
let mut total_cell_width: Au = (column_index..column_index + cell.colspan) let mut total_cell_width: Au = (column_index..column_index + cell.colspan)
@ -2076,12 +2072,10 @@ impl<'a> TableLayout<'a> {
}; };
let border = cell.style.border_width(writing_mode); let border = cell.style.border_width(writing_mode);
collapsed_borders.block[row_index].max_assign(border.block_start.into()); collapsed_borders.block[row_index].max_assign(border.block_start);
collapsed_borders.block[row_index + cell.rowspan] collapsed_borders.block[row_index + cell.rowspan].max_assign(border.block_end);
.max_assign(border.block_end.into()); collapsed_borders.inline[column_index].max_assign(border.inline_start);
collapsed_borders.inline[column_index].max_assign(border.inline_start.into()); collapsed_borders.inline[column_index + cell.colspan].max_assign(border.inline_end);
collapsed_borders.inline[column_index + cell.colspan]
.max_assign(border.inline_end.into());
} }
} }
@ -2092,29 +2086,28 @@ impl<'a> TableLayout<'a> {
&self, &self,
cell: &TableSlotCell, cell: &TableSlotCell,
coordinates: TableSlotCoordinates, coordinates: TableSlotCoordinates,
) -> Option<LogicalSides<Length>> { ) -> Option<LogicalSides<Au>> {
let collapsed_borders = self.collapsed_borders.as_ref()?; let collapsed_borders = self.collapsed_borders.as_ref()?;
let end_x = coordinates.x + cell.colspan; let end_x = coordinates.x + cell.colspan;
let end_y = coordinates.y + cell.rowspan; let end_y = coordinates.y + cell.rowspan;
let mut result: LogicalSides<Length> = LogicalSides { let mut result = LogicalSides {
inline_start: collapsed_borders.inline[coordinates.x], inline_start: collapsed_borders.inline[coordinates.x],
inline_end: collapsed_borders.inline[end_x], inline_end: collapsed_borders.inline[end_x],
block_start: collapsed_borders.block[coordinates.y], block_start: collapsed_borders.block[coordinates.y],
block_end: collapsed_borders.block[end_y], block_end: collapsed_borders.block[end_y],
} };
.into();
if coordinates.x != 0 { if coordinates.x != 0 {
result.inline_start = result.inline_start / 2.0; result.inline_start /= 2;
} }
if coordinates.y != 0 { if coordinates.y != 0 {
result.block_start = result.block_start / 2.0; result.block_start /= 2;
} }
if end_x != self.table.size.width { if end_x != self.table.size.width {
result.inline_end = result.inline_end / 2.0; result.inline_end /= 2;
} }
if end_y != self.table.size.height { if end_y != self.table.size.height {
result.block_end = result.block_end / 2.0; result.block_end /= 2;
} }
Some(result) Some(result)
@ -2436,9 +2429,9 @@ impl Table {
let padding = self let padding = self
.style .style
.padding(writing_mode) .padding(writing_mode)
.percentages_relative_to(Length::zero()); .percentages_relative_to(Au::zero());
let border = self.style.border_width(writing_mode); let border = self.style.border_width(writing_mode);
caption_minimum_inline_size -= (padding.inline_sum() + border.inline_sum()).into(); caption_minimum_inline_size -= padding.inline_sum() + border.inline_sum();
table_content_sizes table_content_sizes
.min_content .min_content
.max_assign(caption_minimum_inline_size); .max_assign(caption_minimum_inline_size);