diff options
| -rw-r--r-- | components/layout_2020/display_list/stacking_context.rs | 8 | ||||
| -rw-r--r-- | components/layout_2020/flexbox/layout.rs | 14 | ||||
| -rw-r--r-- | components/layout_2020/flow/inline/line.rs | 9 | ||||
| -rw-r--r-- | components/layout_2020/flow/inline/mod.rs | 10 | ||||
| -rw-r--r-- | components/layout_2020/flow/mod.rs | 114 | ||||
| -rw-r--r-- | components/layout_2020/formatting_contexts.rs | 2 | ||||
| -rw-r--r-- | components/layout_2020/fragment_tree/box_fragment.rs | 49 | ||||
| -rw-r--r-- | components/layout_2020/geom.rs | 67 | ||||
| -rw-r--r-- | components/layout_2020/lib.rs | 2 | ||||
| -rw-r--r-- | components/layout_2020/positioned.rs | 63 | ||||
| -rw-r--r-- | components/layout_2020/replaced.rs | 7 | ||||
| -rw-r--r-- | components/layout_2020/style_ext.rs | 110 | ||||
| -rw-r--r-- | components/layout_2020/table/layout.rs | 57 |
13 files changed, 240 insertions, 272 deletions
diff --git a/components/layout_2020/display_list/stacking_context.rs b/components/layout_2020/display_list/stacking_context.rs index 248871a4aac..d69e9330371 100644 --- a/components/layout_2020/display_list/stacking_context.rs +++ b/components/layout_2020/display_list/stacking_context.rs @@ -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( diff --git a/components/layout_2020/flexbox/layout.rs b/components/layout_2020/flexbox/layout.rs index 49c110df443..af7d3ec583d 100644 --- a/components/layout_2020/flexbox/layout.rs +++ b/components/layout_2020/flexbox/layout.rs @@ -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() { diff --git a/components/layout_2020/flow/inline/line.rs b/components/layout_2020/flow/inline/line.rs index f89c2e32dfa..81fed6222dc 100644 --- a/components/layout_2020/flow/inline/line.rs +++ b/components/layout_2020/flow/inline/line.rs @@ -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); } } diff --git a/components/layout_2020/flow/inline/mod.rs b/components/layout_2020/flow/inline/mod.rs index 44a284cdf89..123538eebc3 100644 --- a/components/layout_2020/flow/inline/mod.rs +++ b/components/layout_2020/flow/inline/mod.rs @@ -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()); } diff --git a/components/layout_2020/flow/mod.rs b/components/layout_2020/flow/mod.rs index 07ee8ba0307..60a7bffaa90 100644 --- a/components/layout_2020/flow/mod.rs +++ b/components/layout_2020/flow/mod.rs @@ -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) } diff --git a/components/layout_2020/formatting_contexts.rs b/components/layout_2020/formatting_contexts.rs index 1941e7c27ff..b78ad8d836b 100644 --- a/components/layout_2020/formatting_contexts.rs +++ b/components/layout_2020/formatting_contexts.rs @@ -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 } diff --git a/components/layout_2020/fragment_tree/box_fragment.rs b/components/layout_2020/fragment_tree/box_fragment.rs index f15191b298e..10c119df65c 100644 --- a/components/layout_2020/fragment_tree/box_fragment.rs +++ b/components/layout_2020/fragment_tree/box_fragment.rs @@ -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)) } } diff --git a/components/layout_2020/geom.rs b/components/layout_2020/geom.rs index 965d096223b..98bebdcb3c9 100644 --- a/components/layout_2020/geom.rs +++ b/components/layout_2020/geom.rs @@ -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))) } } diff --git a/components/layout_2020/lib.rs b/components/layout_2020/lib.rs index 456ffb7042b..b4c3ae1cf6d 100644 --- a/components/layout_2020/lib.rs +++ b/components/layout_2020/lib.rs @@ -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), diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index cca0a778fe4..99a1c7516e7 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -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, }, }, diff --git a/components/layout_2020/replaced.rs b/components/layout_2020/replaced.rs index aec71c15acb..f5541836848 100644 --- a/components/layout_2020/replaced.rs +++ b/components/layout_2020/replaced.rs @@ -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, diff --git a/components/layout_2020/style_ext.rs b/components/layout_2020/style_ext.rs index d359acc1178..9acf861c93b 100644 --- a/components/layout_2020/style_ext.rs +++ b/components/layout_2020/style_ext.rs @@ -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, ) diff --git a/components/layout_2020/table/layout.rs b/components/layout_2020/table/layout.rs index 713ad684d1c..b9ad442dc33 100644 --- a/components/layout_2020/table/layout.rs +++ b/components/layout_2020/table/layout.rs @@ -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); |