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_x = transform_origin
.horizontal
.percentage_relative_to(border_rect.size.width.into())
.px();
.to_used_value(border_rect.size.width)
.to_f32_px();
let transform_origin_y = transform_origin
.vertical
.percentage_relative_to(border_rect.size.height.into())
.px();
.to_used_value(border_rect.size.height)
.to_f32_px();
let transform_origin_z = transform_origin.depth.px();
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::ComputedValues;
use style::values::computed::length::Size;
use style::values::computed::Length;
use style::values::generics::flex::GenericFlexBasis as FlexBasis;
use style::values::generics::length::{GenericLengthPercentageOrAuto, LengthPercentageOrNormal};
use style::values::specified::align::AlignFlags;
@ -938,15 +937,12 @@ impl FlexContainer {
let min_box_size = self
.style
.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 min_box_size = self.config.flex_axis.vec2_to_flex_relative(min_box_size);
(
min_box_size.cross.into(),
max_box_size.cross.map(Into::into),
)
(min_box_size.cross, 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
.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_max_size = flex_context.vec2_to_flex_relative(max_size);
@ -2361,8 +2357,8 @@ impl FlexItemBox {
Some(container_definite_main_size) => {
let length = length_percentage
.0
.percentage_relative_to(container_definite_main_size.into());
FlexBasis::Size(apply_box_sizing(length.into()))
.to_used_value(container_definite_main_size);
FlexBasis::Size(apply_box_sizing(length))
},
None => {
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();
for fragment in inner_state.fragments.iter_mut() {
match fragment {
Fragment::Float(box_fragment) => {
box_fragment.content_rect.origin -=
pbm_sums.start_offset().to_physical_size(ifc_writing_mode);
},
_ => {},
if let Fragment::Float(box_fragment) = fragment {
box_fragment.content_rect.origin -=
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::properties::style_structs::InheritedText;
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::font::LineHeight;
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
let inline_box = inline_formatting_context.inline_boxes.get(identifier);
let inline_box = (*inline_box).borrow();
let zero = Length::zero();
let zero = Au::zero();
let padding = inline_box
.style
.padding(self.containing_block.style.writing_mode)
@ -2310,14 +2310,14 @@ impl<'layout_data> ContentSizesComputation<'layout_data> {
.style
.margin(self.containing_block.style.writing_mode)
.percentages_relative_to(zero)
.auto_is(Length::zero);
.auto_is(Au::zero);
let pbm = margin + padding + border;
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 {
self.ending_inline_pbm_stack.push(pbm.inline_end.into());
self.ending_inline_pbm_stack.push(pbm.inline_end);
} else {
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::logical_geometry::WritingMode;
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::{Display, TextAlignKeyword};
use style::Zero;
@ -136,7 +136,7 @@ impl BlockLevelBox {
let min_size = style
.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 prefered_size = style.content_box_size(containing_block, &pbm);
let inline_size = prefered_size
@ -144,19 +144,18 @@ impl BlockLevelBox {
.auto_is(|| {
let margin_inline_start = pbm.margin.inline_start.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 -
margin_inline_start -
margin_inline_end)
.into()
margin_inline_end
})
.clamp_between_extremums(min_size.inline, max_size.inline);
let block_size = prefered_size
.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 {
inline_size: inline_size.into(),
inline_size,
block_size,
style,
};
@ -384,7 +383,7 @@ fn calculate_inline_content_size_for_block_level_boxes(
} => {
let size = sizing::outer_inline(
style,
&containing_block,
containing_block,
&LogicalVec2::zero(),
false, /* auto_block_size_stretches_to_containing_block */
|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(),
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.
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
.adjoin_assign(&collapsible_margins_in_children.end);
} 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(|| {
content_block_size
.clamp_between_extremums(min_box_size.block, max_box_size.block)
.into()
content_block_size.clamp_between_extremums(min_box_size.block, max_box_size.block)
});
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
// as long as no floats in the overflowing content lowered it.
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 {
@ -995,10 +992,9 @@ impl NonReplacedFormattingContext {
Some(inline_size) => (layout.content_block_size, inline_size),
None => (
containing_block_for_children.block_size.auto_is(|| {
layout.content_block_size.clamp_between_extremums(
min_box_size.block.into(),
max_box_size.block.map(|t| t.into()),
)
layout
.content_block_size
.clamp_between_extremums(min_box_size.block, max_box_size.block)
}),
containing_block_for_children.inline_size,
),
@ -1054,7 +1050,7 @@ impl NonReplacedFormattingContext {
let min_box_size = self
.style
.content_min_box_size(containing_block, &pbm)
.auto_is(Length::zero);
.auto_is(Au::zero);
let block_size = box_size.block.map(|block_size| {
block_size.clamp_between_extremums(min_box_size.block, max_box_size.block)
});
@ -1079,15 +1075,15 @@ impl NonReplacedFormattingContext {
let clearance;
let mut content_size;
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 =
inline_size.clamp_between_extremums(min_box_size.inline, max_box_size.inline);
layout = self.layout(
layout_context,
positioning_context,
&ContainingBlock {
inline_size: inline_size.into(),
block_size: block_size.map(|t| t.into()),
inline_size,
block_size,
style: &self.style,
},
containing_block,
@ -1097,12 +1093,12 @@ impl NonReplacedFormattingContext {
content_size = LogicalVec2 {
block: layout.content_block_size,
inline: inline_size,
}
.into();
};
} else {
content_size = LogicalVec2 {
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)
}),
inline: inline_size,
@ -1118,7 +1114,7 @@ impl NonReplacedFormattingContext {
&collapsed_margin_block_start,
containing_block,
&pbm,
content_size + pbm.padding_border_sums.into(),
content_size + pbm.padding_border_sums,
&self.style,
);
} else {
@ -1135,8 +1131,8 @@ impl NonReplacedFormattingContext {
// Create a PlacementAmongFloats using the minimum size in all dimensions as the object size.
let minimum_size_of_block = LogicalVec2 {
inline: min_box_size.inline.into(),
block: block_size.auto_is(|| min_box_size.block).into(),
inline: min_box_size.inline,
block: block_size.auto_is(|| min_box_size.block),
} + pbm.padding_border_sums;
let mut placement = PlacementAmongFloats::new(
&sequential_layout_state.floats,
@ -1149,8 +1145,9 @@ impl NonReplacedFormattingContext {
loop {
// First try to place the block using the minimum size as the object size.
placement_rect = placement.place();
let proposed_inline_size =
Length::from(placement_rect.size.inline - pbm.padding_border_sums.inline)
let proposed_inline_size = placement_rect.size.inline -
pbm.padding_border_sums
.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.
@ -1161,8 +1158,8 @@ impl NonReplacedFormattingContext {
layout_context,
positioning_context,
&ContainingBlock {
inline_size: proposed_inline_size.into(),
block_size: block_size.map(|t| t.into()),
inline_size: proposed_inline_size,
block_size,
style: &self.style,
},
containing_block,
@ -1185,12 +1182,12 @@ impl NonReplacedFormattingContext {
content_size = LogicalVec2 {
block: layout.content_block_size,
inline: inline_size,
}
.into();
};
} else {
content_size = LogicalVec2 {
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)
}),
inline: proposed_inline_size,
@ -1201,7 +1198,7 @@ impl NonReplacedFormattingContext {
// size of auto. Try to fit it into our precalculated placement among the
// floats. If it fits, then we can stop trying layout candidates.
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,
) {
break;
@ -1233,8 +1230,8 @@ impl NonReplacedFormattingContext {
sequential_layout_state,
containing_block,
&pbm,
content_size.inline + pbm.padding_border_sums.inline.into(),
placement_rect.into(),
content_size.inline + pbm.padding_border_sums.inline,
placement_rect,
);
}
@ -1255,9 +1252,7 @@ impl NonReplacedFormattingContext {
// Margins can never collapse into independent formatting contexts.
sequential_layout_state.collapse_margins();
sequential_layout_state.advance_block_position(
pbm.padding_border_sums.block +
Au::from(content_size.block) +
clearance.unwrap_or_else(Au::zero),
pbm.padding_border_sums.block + content_size.block + clearance.unwrap_or_else(Au::zero),
);
sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end));
@ -1270,7 +1265,7 @@ impl NonReplacedFormattingContext {
pbm.border.inline_start +
effective_margin_inline_start,
},
size: content_size.into(),
size: content_size,
};
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,
containing_block,
&pbm,
size.into(),
size,
style,
);
@ -1399,8 +1394,8 @@ fn layout_in_flow_replaced_block_level(
struct ContainingBlockPaddingAndBorder<'a> {
containing_block: ContainingBlock<'a>,
pbm: PaddingBorderMargin,
min_box_size: LogicalVec2<Length>,
max_box_size: LogicalVec2<Option<Length>>,
min_box_size: LogicalVec2<Au>,
max_box_size: LogicalVec2<Option<Au>>,
}
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 min_box_size = style
.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/visudet.html#min-max-widths
@ -1439,24 +1434,23 @@ fn solve_containing_block_padding_and_border_for_in_flow_box<'a>(
.auto_is(|| {
let margin_inline_start = pbm.margin.inline_start.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 -
margin_inline_start -
margin_inline_end)
.into()
margin_inline_end
})
.clamp_between_extremums(min_box_size.inline, max_box_size.inline);
// https://drafts.csswg.org/css2/#the-height-property
// https://drafts.csswg.org/css2/visudet.html#min-max-heights
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);
}
let containing_block_for_children = ContainingBlock {
inline_size: inline_size.into(),
block_size: block_size.map(|t| t.into()),
inline_size,
block_size,
style,
};
// https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
@ -1585,14 +1579,14 @@ fn solve_inline_margins_avoiding_floats(
sequential_layout_state: &SequentialLayoutState,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
inline_size: Length,
placement_rect: LogicalRect<Length>,
inline_size: Au,
placement_rect: LogicalRect<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());
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 end_adjustment = cb_info.inline_end - placement_rect.max_inline_position().into();
let start_adjustment = placement_rect.start_corner.inline - cb_info.inline_start;
let end_adjustment = cb_info.inline_end - placement_rect.max_inline_position();
let mut justification = Au::zero();
let inline_margins = match (pbm.margin.inline_start, pbm.margin.inline_end) {
(AuOrAuto::Auto, AuOrAuto::Auto) => {
@ -1625,7 +1619,7 @@ fn solve_clearance_and_inline_margins_avoiding_floats(
block_start_margin: &CollapsedMargin,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
size: LogicalVec2<Length>,
size: LogicalVec2<Au>,
style: &Arc<ComputedValues>,
) -> (Option<Au>, (Au, Au), Au) {
let (clearance, placement_rect) = sequential_layout_state
@ -1633,14 +1627,14 @@ fn solve_clearance_and_inline_margins_avoiding_floats(
style.get_box().clear,
block_start_margin,
pbm,
size.into(),
size,
);
let (inline_margins, effective_margin_inline_start) = solve_inline_margins_avoiding_floats(
sequential_layout_state,
containing_block,
pbm,
size.inline,
placement_rect.into(),
placement_rect,
);
(clearance, inline_margins, effective_margin_inline_start)
}

2
components/layout_2020/formatting_contexts.rs
View file

@ -287,7 +287,7 @@ impl NonReplacedFormattingContext {
.insert((
containing_block_for_children.size.block,
self.contents
.inline_content_sizes(layout_context, &containing_block_for_children),
.inline_content_sizes(layout_context, containing_block_for_children),
))
.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::logical_geometry::WritingMode;
use style::properties::ComputedValues;
use style::values::computed::{CSSPixelLength, Length, LengthPercentage, LengthPercentageOrAuto};
use style::values::computed::{LengthPercentage, LengthPercentageOrAuto};
use style::Zero;
use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment};
@ -304,7 +304,7 @@ impl BoxFragment {
return resolved_sticky_insets;
}
let convert_to_length_or_auto = |sides: PhysicalSides<Au>| {
let convert_to_au_or_auto = |sides: PhysicalSides<Au>| {
PhysicalSides::new(
AuOrAuto::LengthPercentage(sides.top),
AuOrAuto::LengthPercentage(sides.right),
@ -321,29 +321,23 @@ impl BoxFragment {
// https://drafts.csswg.org/cssom/#resolved-values
let insets = self.style.get_position();
if position == ComputedPosition::Relative {
let get_resolved_axis =
|start: &LengthPercentageOrAuto,
end: &LengthPercentageOrAuto,
container_length: CSSPixelLength| {
let start = start.map(|v| v.percentage_relative_to(container_length));
let end = end.map(|v| v.percentage_relative_to(container_length));
match (start.non_auto(), end.non_auto()) {
(None, None) => (Length::zero(), Length::zero()),
(None, Some(end)) => (-end, end),
(Some(start), None) => (start, -start),
// This is the overconstrained case, for which the resolved insets will
// simply be the computed insets.
(Some(start), Some(end)) => (start, end),
}
};
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.into());
return convert_to_length_or_auto(PhysicalSides::new(
top.into(),
right.into(),
bottom.into(),
left.into(),
));
let get_resolved_axis = |start: &LengthPercentageOrAuto,
end: &LengthPercentageOrAuto,
container_length: Au| {
let start = start.map(|value| value.to_used_value(container_length));
let end = end.map(|value| value.to_used_value(container_length));
match (start.non_auto(), end.non_auto()) {
(None, None) => (Au::zero(), Au::zero()),
(None, Some(end)) => (-end, end),
(Some(start), None) => (start, -start),
// This is the overconstrained case, for which the resolved insets will
// simply be the computed insets.
(Some(start), Some(end)) => (start, end),
}
};
let (left, right) = get_resolved_axis(&insets.left, &insets.right, cb_width);
let (top, bottom) = get_resolved_axis(&insets.top, &insets.bottom, cb_height);
return convert_to_au_or_auto(PhysicalSides::new(top, right, bottom, left));
}
debug_assert!(
@ -353,8 +347,7 @@ impl BoxFragment {
let resolve = |value: &LengthPercentageOrAuto, container_length: Au| -> Au {
value
.auto_is(LengthPercentage::zero)
.percentage_relative_to(container_length.into())
.into()
.to_used_value(container_length)
};
let (top, bottom) = if self.overconstrained.height {
@ -374,6 +367,6 @@ impl BoxFragment {
(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(
&self,
containing_block: &ContainingBlock,
) -> LogicalVec2<LengthOrAuto> {
) -> LogicalVec2<AuOrAuto> {
LogicalVec2 {
inline: self
.inline
.percentage_relative_to(containing_block.inline_size.into()),
block: self.block.maybe_percentage_relative_to(
containing_block.block_size.map(|t| t.into()).non_auto(),
),
.map(|value| value.to_used_value(containing_block.inline_size)),
block: {
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<'_>> {
pub(crate) fn percentages_relative_to_basis(
&self,
basis: &LogicalVec2<Length>,
) -> LogicalVec2<LengthOrAuto> {
basis: &LogicalVec2<Au>,
) -> LogicalVec2<AuOrAuto> {
LogicalVec2 {
inline: self.inline.percentage_relative_to(basis.inline),
block: self.block.percentage_relative_to(basis.block),
inline: self.inline.map(|value| value.to_used_value(basis.inline)),
block: self.block.map(|value| value.to_used_value(basis.block)),
}
}
}
@ -181,11 +187,22 @@ impl LogicalVec2<LengthPercentageOrAuto<'_>> {
impl LogicalVec2<LengthPercentageOrAuto<'_>> {
pub(crate) fn maybe_percentages_relative_to_basis(
&self,
basis: &LogicalVec2<Option<Length>>,
) -> LogicalVec2<LengthOrAuto> {
basis: &LogicalVec2<Option<Au>>,
) -> LogicalVec2<AuOrAuto> {
let basis = basis.map(|value| value.map(Into::into));
LogicalVec2 {
inline: self.inline.maybe_percentage_relative_to(basis.inline),
block: self.block.maybe_percentage_relative_to(basis.block),
inline: self
.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(
&self,
containing_block: &ContainingBlock,
) -> LogicalVec2<Option<Length>> {
) -> LogicalVec2<Option<Au>> {
LogicalVec2 {
inline: self
.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| {
lp.maybe_percentage_relative_to(
containing_block.block_size.map(|t| t.into()).non_auto(),
)
lp.maybe_to_used_value(containing_block.block_size.map(Into::into).non_auto())
}),
}
}
@ -211,15 +226,15 @@ impl LogicalVec2<Option<&'_ LengthPercentage>> {
impl LogicalVec2<Option<&'_ LengthPercentage>> {
pub(crate) fn maybe_percentages_relative_to_basis(
&self,
basis: &LogicalVec2<Option<Length>>,
) -> LogicalVec2<Option<Length>> {
basis: &LogicalVec2<Option<Au>>,
) -> LogicalVec2<Option<Au>> {
LogicalVec2 {
inline: self
.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
.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> {
pub fn percentages_relative_to(&self, basis: Length) -> LogicalSides<Length> {
self.map(|s| s.percentage_relative_to(basis))
pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<Au> {
self.map(|value| value.to_used_value(basis))
}
}
impl LogicalSides<LengthPercentageOrAuto<'_>> {
pub fn percentages_relative_to(&self, basis: Length) -> LogicalSides<LengthOrAuto> {
self.map(|s| s.percentage_relative_to(basis))
pub fn percentages_relative_to(&self, basis: Au) -> LogicalSides<AuOrAuto> {
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>,
) -> Self {
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| {
v.clamp_between_extremums(
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,
};
use crate::geom::{
AuOrAuto, LengthOrAuto, LengthPercentageOrAuto, LogicalRect, LogicalSides, LogicalVec2,
PhysicalPoint, PhysicalRect, PhysicalVec, ToLogical,
AuOrAuto, LengthPercentageOrAuto, LogicalRect, LogicalSides, LogicalVec2, PhysicalPoint,
PhysicalRect, PhysicalVec, ToLogical,
};
use crate::style_ext::{ComputedValuesExt, DisplayInside};
use crate::{ContainingBlock, DefiniteContainingBlock, IndefiniteContainingBlock};
@ -466,8 +466,8 @@ impl HoistedAbsolutelyPositionedBox {
&pbm,
);
LogicalVec2 {
inline: LengthOrAuto::LengthPercentage(used_size.inline.into()),
block: LengthOrAuto::LengthPercentage(used_size.block.into()),
inline: AuOrAuto::LengthPercentage(used_size.inline),
block: AuOrAuto::LengthPercentage(used_size.block),
}
},
IndependentFormattingContext::NonReplaced(..) => {
@ -532,10 +532,8 @@ impl HoistedAbsolutelyPositionedBox {
block: block_axis_solver.is_overconstrained_for_size(computed_size.block),
};
let mut inline_axis =
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.map(|t| t.into()));
let mut inline_axis = inline_axis_solver.solve_for_size(computed_size.inline);
let mut block_axis = block_axis_solver.solve_for_size(computed_size.block);
let mut positioning_context =
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-height
let style = &replaced.style;
content_size = computed_size.auto_is(|| unreachable!()).into();
content_size = computed_size.auto_is(|| unreachable!());
fragments = replaced.contents.make_fragments(
style,
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),
},
(Some(start), None) => AxisResult {
anchor: Anchor::Start(
start
.percentage_relative_to(self.containing_size.into())
.into(),
),
anchor: Anchor::Start(start.to_used_value(self.containing_size)),
size: computed_size,
margin_start: self.computed_margin_start.auto_is(Au::zero),
margin_end: self.computed_margin_end.auto_is(Au::zero),
},
(None, Some(end)) => AxisResult {
anchor: Anchor::End(
end.percentage_relative_to(self.containing_size.into())
.into(),
),
anchor: Anchor::End(end.to_used_value(self.containing_size)),
size: computed_size,
margin_start: self.computed_margin_start.auto_is(Au::zero),
margin_end: self.computed_margin_end.auto_is(Au::zero),
},
(Some(start), Some(end)) => {
let start = start.percentage_relative_to(self.containing_size.into());
let end = end.percentage_relative_to(self.containing_size.into());
let start = start.to_used_value(self.containing_size);
let end = end.to_used_value(self.containing_size);
let margin_start;
let margin_end;
let used_size;
if let AuOrAuto::LengthPercentage(s) = computed_size {
used_size = s;
let margins = self.containing_size -
start.into() -
end.into() -
self.padding_border_sum -
s;
let margins = self.containing_size - start - end - self.padding_border_sum - s;
match (self.computed_margin_start, self.computed_margin_end) {
(AuOrAuto::Auto, AuOrAuto::Auto) => {
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
// clamp it to ‘min-inline-size’ or ‘min-block-size’.
used_size = self.containing_size -
start.into() -
end.into() -
start -
end -
self.padding_border_sum -
margin_start -
margin_end;
};
AxisResult {
anchor: Anchor::Start(start.into()),
anchor: Anchor::Start(start),
size: AuOrAuto::LengthPercentage(used_size),
margin_start,
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() &&
self.box_offsets.both_specified() &&
!self.computed_margin_start.is_auto() &&
@ -946,12 +933,12 @@ impl<'a> AbsoluteAxisSolver<'a> {
) {
(None, None) => self.static_position_rect_axis,
(Some(start), Some(end)) => {
let start = start.percentage_relative_to(self.containing_size.into());
let end = end.percentage_relative_to(self.containing_size.into());
let start = start.to_used_value(self.containing_size);
let end = end.to_used_value(self.containing_size);
RectAxis {
origin: start.into(),
length: self.containing_size - (end + start).into(),
origin: start,
length: self.containing_size - (end + start),
}
},
_ => return None,
@ -1021,11 +1008,11 @@ pub(crate) fn relative_adjustement(
let box_offsets = style
.box_offsets(containing_block)
.map_inline_and_block_axes(
|v| v.percentage_relative_to(cbis.into()).map(Au::from),
|v| match cbbs.non_auto() {
Some(cbbs) => v.percentage_relative_to(cbbs.into()).map(Au::from),
None => match v.non_auto().and_then(|v| v.to_length()) {
Some(v) => AuOrAuto::LengthPercentage(v.into()),
|value| value.map(|value| value.to_used_value(cbis)),
|value| match cbbs.non_auto() {
Some(cbbs) => value.map(|value| value.to_used_value(cbbs)),
None => match value.non_auto().and_then(|value| value.to_length()) {
Some(value) => AuOrAuto::LengthPercentage(value.into()),
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
// ratio when box-sizing is border-box and the inner box size
// 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
.content_min_box_size(containing_block, pbm)
.map(|v| v.map(Au::from))
.auto_is(Au::zero);
let max_box_size = style
.content_max_box_size(containing_block, pbm)
.map(|v| v.map(Au::from));
let max_box_size = style.content_max_box_size(containing_block, pbm);
self.used_size_as_if_inline_element_from_content_box_sizes(
containing_block,
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::values::computed::basic_shape::ClipPath;
use style::values::computed::image::Image as ComputedImageLayer;
use style::values::computed::{
AlignItems, Length, LengthPercentage, NonNegativeLengthPercentage, Size,
};
use style::values::computed::{AlignItems, LengthPercentage, NonNegativeLengthPercentage, Size};
use style::values::generics::box_::Perspective;
use style::values::generics::length::MaxSize;
use style::values::generics::position::{GenericAspectRatio, PreferredRatio};
@ -30,8 +28,7 @@ use webrender_api as wr;
use crate::dom_traversal::Contents;
use crate::fragment_tree::FragmentFlags;
use crate::geom::{
AuOrAuto, LengthOrAuto, LengthPercentageOrAuto, LogicalSides, LogicalVec2, PhysicalSides,
PhysicalSize,
AuOrAuto, LengthPercentageOrAuto, LogicalSides, LogicalVec2, PhysicalSides, PhysicalSize,
};
use crate::{ContainingBlock, IndefiniteContainingBlock};
@ -210,32 +207,32 @@ pub(crate) trait ComputedValuesExt {
&self,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>;
) -> LogicalVec2<AuOrAuto>;
fn content_box_size_for_box_size(
&self,
box_size: LogicalVec2<LengthOrAuto>,
box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>;
) -> LogicalVec2<AuOrAuto>;
fn content_min_box_size(
&self,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>;
) -> LogicalVec2<AuOrAuto>;
fn content_min_box_size_for_min_size(
&self,
box_size: LogicalVec2<LengthOrAuto>,
box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto>;
) -> LogicalVec2<AuOrAuto>;
fn content_max_box_size(
&self,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>>;
) -> LogicalVec2<Option<Au>>;
fn content_max_box_size_for_max_size(
&self,
box_size: LogicalVec2<Option<Length>>,
box_size: LogicalVec2<Option<Au>>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>>;
) -> LogicalVec2<Option<Au>>;
fn content_box_sizes_and_padding_border_margin(
&self,
containing_block: &IndefiniteContainingBlock,
@ -259,7 +256,7 @@ pub(crate) trait ComputedValuesExt {
&self,
containing_block_writing_mode: WritingMode,
) -> 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(
&self,
containing_block_writing_mode: WritingMode,
@ -363,7 +360,7 @@ impl ComputedValuesExt for ComputedValues {
&self,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> {
) -> LogicalVec2<AuOrAuto> {
let box_size = self
.box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block);
@ -372,9 +369,9 @@ impl ComputedValuesExt for ComputedValues {
fn content_box_size_for_box_size(
&self,
box_size: LogicalVec2<LengthOrAuto>,
box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> {
) -> LogicalVec2<AuOrAuto> {
match self.get_position().box_sizing {
BoxSizing::ContentBox => box_size,
BoxSizing::BorderBox => LogicalVec2 {
@ -382,10 +379,10 @@ impl ComputedValuesExt for ComputedValues {
// which is clamped to zero.
inline: box_size
.inline
.map(|i| i - pbm.padding_border_sums.inline.into()),
.map(|value| value - pbm.padding_border_sums.inline),
block: box_size
.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,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> {
) -> LogicalVec2<AuOrAuto> {
let box_size = self
.min_box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block);
@ -403,19 +400,19 @@ impl ComputedValuesExt for ComputedValues {
fn content_min_box_size_for_min_size(
&self,
min_box_size: LogicalVec2<LengthOrAuto>,
min_box_size: LogicalVec2<AuOrAuto>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<LengthOrAuto> {
) -> LogicalVec2<AuOrAuto> {
match self.get_position().box_sizing {
BoxSizing::ContentBox => min_box_size,
BoxSizing::BorderBox => LogicalVec2 {
// Clamp to zero to make sure the used size components are non-negative
inline: min_box_size
.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
.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,
containing_block: &ContainingBlock,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>> {
) -> LogicalVec2<Option<Au>> {
let max_box_size = self
.max_box_size(containing_block.effective_writing_mode())
.percentages_relative_to(containing_block);
@ -434,9 +431,9 @@ impl ComputedValuesExt for ComputedValues {
fn content_max_box_size_for_max_size(
&self,
max_box_size: LogicalVec2<Option<Length>>,
max_box_size: LogicalVec2<Option<Au>>,
pbm: &PaddingBorderMargin,
) -> LogicalVec2<Option<Length>> {
) -> LogicalVec2<Option<Au>> {
match self.get_position().box_sizing {
BoxSizing::ContentBox => max_box_size,
BoxSizing::BorderBox => {
@ -445,10 +442,10 @@ impl ComputedValuesExt for ComputedValues {
LogicalVec2 {
inline: max_box_size
.inline
.map(|i| i - pbm.padding_border_sums.inline.into()),
.map(|value| value - pbm.padding_border_sums.inline),
block: max_box_size
.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.
// However, for min size properties, as well as for margins and paddings,
// 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 =
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 pbm = self.padding_border_margin_with_writing_mode_and_containing_block_inline_size(
writing_mode,
@ -501,19 +498,19 @@ impl ComputedValuesExt for ComputedValues {
let cbis = containing_block.inline_size;
let padding = self
.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 margin = self
.margin(containing_block.effective_writing_mode())
.percentages_relative_to(cbis.into());
.percentages_relative_to(cbis);
PaddingBorderMargin {
padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(),
block: (padding.block_sum() + border.block_sum()).into(),
inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()),
},
padding: padding.into(),
border: border.into(),
margin: margin.map(|t| t.map(|m| m.into())),
padding,
border,
margin,
}
}
@ -523,19 +520,19 @@ impl ComputedValuesExt for ComputedValues {
) -> PaddingBorderMargin {
let padding = self
.padding(writing_mode)
.percentages_relative_to(Length::zero());
.percentages_relative_to(Au::zero());
let border = self.border_width(writing_mode);
let margin = self
.margin(writing_mode)
.percentages_relative_to(Length::zero());
.percentages_relative_to(Au::zero());
PaddingBorderMargin {
padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(),
block: (padding.block_sum() + border.block_sum()).into(),
inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()),
},
padding: padding.into(),
border: border.into(),
margin: margin.map(|t| t.map(|m| m.into())),
padding,
border,
margin,
}
}
@ -544,7 +541,6 @@ impl ComputedValuesExt for ComputedValues {
writing_mode: WritingMode,
containing_block_inline_size: Au,
) -> PaddingBorderMargin {
let containing_block_inline_size = containing_block_inline_size.into();
let padding = self
.padding(writing_mode)
.percentages_relative_to(containing_block_inline_size);
@ -554,12 +550,12 @@ impl ComputedValuesExt for ComputedValues {
.percentages_relative_to(containing_block_inline_size);
PaddingBorderMargin {
padding_border_sums: LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(),
block: (padding.block_sum() + border.block_sum()).into(),
inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()),
},
padding: padding.into(),
border: border.into(),
margin: margin.map(|margin_side| margin_side.map(Into::into)),
padding,
border,
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();
LogicalSides::from_physical(
&PhysicalSides::new(
border.border_top_width.into(),
border.border_right_width.into(),
border.border_bottom_width.into(),
border.border_left_width.into(),
border.border_top_width,
border.border_right_width,
border.border_bottom_width,
border.border_left_width,
),
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::logical_geometry::WritingMode;
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::length::GenericLengthPercentageOrAuto::{Auto, LengthPercentage};
use style::Zero;
@ -185,7 +185,7 @@ impl<'a> TableLayout<'a> {
let padding = cell
.style
.padding(writing_mode)
.percentages_relative_to(Length::zero());
.percentages_relative_to(Au::zero());
let border = self
.get_collapsed_borders_for_cell(
@ -195,8 +195,8 @@ impl<'a> TableLayout<'a> {
.unwrap_or_else(|| cell.style.border_width(writing_mode));
let padding_border_sums = LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum()).into(),
block: (padding.block_sum() + border.block_sum()).into(),
inline: (padding.inline_sum() + border.inline_sum()),
block: (padding.block_sum() + border.block_sum()),
};
let (size, min_size, max_size) =
@ -681,18 +681,17 @@ impl<'a> TableLayout<'a> {
let padding = context
.style
.padding(writing_mode)
.percentages_relative_to(Length::zero());
.percentages_relative_to(Au::zero());
let border = context.style.border_width(writing_mode);
let margin = context
.style
.margin(writing_mode)
.percentages_relative_to(Length::zero())
.auto_is(Length::zero);
.percentages_relative_to(Au::zero())
.auto_is(Au::zero);
let padding_border_sums = LogicalVec2 {
inline: (padding.inline_sum() + border.inline_sum() + margin.inline_sum())
.into(),
block: (padding.block_sum() + border.block_sum() + margin.block_sum()).into(),
inline: (padding.inline_sum() + border.inline_sum() + margin.inline_sum()),
block: (padding.block_sum() + border.block_sum() + margin.block_sum()),
};
let (size, min_size, max_size) =
@ -752,8 +751,7 @@ impl<'a> TableLayout<'a> {
let min_width: Au = style
.content_min_box_size(containing_block_for_table, &self.pbm)
.inline
.auto_is(Length::zero)
.into();
.auto_is(Au::zero);
resolved_table_width
.clamp(grid_min_max.min_content, grid_min_max.max_content)
.max(min_width)
@ -1140,14 +1138,12 @@ impl<'a> TableLayout<'a> {
cell.style.border_width(
containing_block_for_table.effective_writing_mode(),
)
})
.into();
});
let padding: LogicalSides<Au> = cell
.style
.padding(containing_block_for_table.effective_writing_mode())
.percentages_relative_to(self.basis_for_cell_padding_percentage.into())
.into();
.percentages_relative_to(self.basis_for_cell_padding_percentage);
let inline_border_padding_sum = border.inline_sum() + padding.inline_sum();
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);
collapsed_borders.block[row_index].max_assign(border.block_start.into());
collapsed_borders.block[row_index + cell.rowspan]
.max_assign(border.block_end.into());
collapsed_borders.inline[column_index].max_assign(border.inline_start.into());
collapsed_borders.inline[column_index + cell.colspan]
.max_assign(border.inline_end.into());
collapsed_borders.block[row_index].max_assign(border.block_start);
collapsed_borders.block[row_index + cell.rowspan].max_assign(border.block_end);
collapsed_borders.inline[column_index].max_assign(border.inline_start);
collapsed_borders.inline[column_index + cell.colspan].max_assign(border.inline_end);
}
}
@ -2092,29 +2086,28 @@ impl<'a> TableLayout<'a> {
&self,
cell: &TableSlotCell,
coordinates: TableSlotCoordinates,
) -> Option<LogicalSides<Length>> {
) -> Option<LogicalSides<Au>> {
let collapsed_borders = self.collapsed_borders.as_ref()?;
let end_x = coordinates.x + cell.colspan;
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_end: collapsed_borders.inline[end_x],
block_start: collapsed_borders.block[coordinates.y],
block_end: collapsed_borders.block[end_y],
}
.into();
};
if coordinates.x != 0 {
result.inline_start = result.inline_start / 2.0;
result.inline_start /= 2;
}
if coordinates.y != 0 {
result.block_start = result.block_start / 2.0;
result.block_start /= 2;
}
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 {
result.block_end = result.block_end / 2.0;
result.block_end /= 2;
}
Some(result)
@ -2436,9 +2429,9 @@ impl Table {
let padding = self
.style
.padding(writing_mode)
.percentages_relative_to(Length::zero());
.percentages_relative_to(Au::zero());
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
.min_content
.max_assign(caption_minimum_inline_size);