Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-23 15:23:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

layout: Remove min and max container sizes from FlexContext (#35144)

Browse source 
Thanks to #34946 we don't have to recompute the min and max sizes, we
can get them from the `ContainingBlock`.

And then in `FlexContext` there is no need to store both the definite
and the min & max sizes of the container`, we can instead make do with
a single `FlexRelativeVec2<SizeConstraint>`.

This removes 1 of the 3 usages of `ContentBoxSizesAndPBMDeprecated`,
which is also good.

Signed-off-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
Oriol Brufau 2025-01-24 08:11:23 -08:00 • committed by GitHub
parent 56d55d48d9
commit fea8b68860
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 54 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

9
components/layout_2020/flexbox/geom.rs
View file

@ -14,6 +14,15 @@ pub(super) struct FlexRelativeVec2<T> {
pub cross: T, pub cross: T,
} }
impl<T> FlexRelativeVec2<T> {
pub fn map<U>(&self, f: impl Fn(&T) -> U) -> FlexRelativeVec2<U> {
FlexRelativeVec2 {
main: f(&self.main),
cross: f(&self.cross),
}
}
}
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub(super) struct FlexRelativeSides<T> { pub(super) struct FlexRelativeSides<T> {
pub cross_start: T, pub cross_start: T,

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

@ -57,9 +57,7 @@ struct FlexContext<'a> {
layout_context: &'a LayoutContext<'a>, layout_context: &'a LayoutContext<'a>,
positioning_context: &'a mut PositioningContext, positioning_context: &'a mut PositioningContext,
containing_block: &'a ContainingBlock<'a>, // For items containing_block: &'a ContainingBlock<'a>, // For items
container_min_cross_size: Au, container_inner_size_constraint: FlexRelativeVec2<SizeConstraint>,
container_max_cross_size: Option<Au>,
container_definite_inner_size: FlexRelativeVec2<Option<Au>>,
} }
/// A flex item with some intermediate results /// A flex item with some intermediate results
@ -644,26 +642,19 @@ impl FlexContainer {
layout_context: &LayoutContext, layout_context: &LayoutContext,
positioning_context: &mut PositioningContext, positioning_context: &mut PositioningContext,
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
containing_block_for_container: &ContainingBlock,
) -> IndependentLayout { ) -> IndependentLayout {
let (container_min_size, container_max_size, depends_on_block_constraints) = let depends_on_block_constraints = self.config.flex_direction == FlexDirection::Column;
self.available_space_for_flex_items(containing_block_for_container);
let depends_on_block_constraints =
depends_on_block_constraints || self.config.flex_direction == FlexDirection::Column;
let mut flex_context = FlexContext { let mut flex_context = FlexContext {
config: self.config.clone(), config: self.config.clone(),
layout_context, layout_context,
positioning_context, positioning_context,
containing_block, containing_block,
container_min_cross_size: container_min_size.cross,
container_max_cross_size: container_max_size.cross,
// https://drafts.csswg.org/css-flexbox/#definite-sizes // https://drafts.csswg.org/css-flexbox/#definite-sizes
container_definite_inner_size: self.config.flex_axis.vec2_to_flex_relative( container_inner_size_constraint: self.config.flex_axis.vec2_to_flex_relative(
LogicalVec2 { LogicalVec2 {
inline: Some(containing_block.size.inline), inline: SizeConstraint::Definite(containing_block.size.inline),
block: containing_block.size.block.to_definite(), block: containing_block.size.block,
}, },
), ),
}; };
@ -674,11 +665,11 @@ impl FlexContainer {
FlexAxis::Row => containing_block.size.inline, FlexAxis::Row => containing_block.size.inline,
FlexAxis::Column => match containing_block.size.block { FlexAxis::Column => match containing_block.size.block {
SizeConstraint::Definite(size) => size, SizeConstraint::Definite(size) => size,
_ => self SizeConstraint::MinMax(min, max) => self
.main_content_sizes(layout_context, &containing_block.into(), || &flex_context) .main_content_sizes(layout_context, &containing_block.into(), || &flex_context)
.sizes .sizes
.max_content .max_content
.clamp_between_extremums(container_min_size.main, container_max_size.main), .clamp_between_extremums(min, max),
}, },
}; };
@ -726,13 +717,23 @@ impl FlexContainer {
}; };
let cross_gap = match cross_gap { let cross_gap = match cross_gap {
LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
.maybe_to_used_value(flex_context.container_definite_inner_size.cross) .maybe_to_used_value(
flex_context
.container_inner_size_constraint
.cross
.to_definite(),
)
.unwrap_or_default(), .unwrap_or_default(),
LengthPercentageOrNormal::Normal => Au::zero(), LengthPercentageOrNormal::Normal => Au::zero(),
}; };
let main_gap = match main_gap { let main_gap = match main_gap {
LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
.maybe_to_used_value(flex_context.container_definite_inner_size.main) .maybe_to_used_value(
flex_context
.container_inner_size_constraint
.main
.to_definite(),
)
.unwrap_or_default(), .unwrap_or_default(),
LengthPercentageOrNormal::Normal => Au::zero(), LengthPercentageOrNormal::Normal => Au::zero(),
}; };
@ -754,14 +755,12 @@ impl FlexContainer {
cross_gap * (line_count as i32 - 1); cross_gap * (line_count as i32 - 1);
// https://drafts.csswg.org/css-flexbox/#algo-cross-container // https://drafts.csswg.org/css-flexbox/#algo-cross-container
let container_cross_size = flex_context let container_cross_size = match flex_context.container_inner_size_constraint.cross {
.container_definite_inner_size SizeConstraint::Definite(cross_size) => cross_size,
.cross SizeConstraint::MinMax(min, max) => {
.unwrap_or(content_cross_size) content_cross_size.clamp_between_extremums(min, max)
.clamp_between_extremums( },
flex_context.container_min_cross_size, };
flex_context.container_max_cross_size,
);
let container_size = FlexRelativeVec2 { let container_size = FlexRelativeVec2 {
main: container_main_size, main: container_main_size,
@ -773,11 +772,11 @@ impl FlexContainer {
.vec2_to_flow_relative(container_size) .vec2_to_flow_relative(container_size)
.block; .block;
let mut remaining_free_cross_space = flex_context let mut remaining_free_cross_space =
.container_definite_inner_size match flex_context.container_inner_size_constraint.cross {
.cross SizeConstraint::Definite(cross_size) => cross_size - content_cross_size,
.map(|cross_size| cross_size - content_cross_size) _ => Au::zero(),
.unwrap_or_default(); };
// Implement fallback alignment. // Implement fallback alignment.
// //
@ -1048,31 +1047,6 @@ impl FlexContainer {
Fragment::AbsoluteOrFixedPositioned(hoisted_fragment) Fragment::AbsoluteOrFixedPositioned(hoisted_fragment)
} }
fn available_space_for_flex_items(
&self,
containing_block_for_container: &ContainingBlock,
) -> (FlexRelativeVec2<Au>, FlexRelativeVec2<Option<Au>>, bool) {
let sizes: ContentBoxSizesAndPBMDeprecated = self
.layout_style()
.content_box_sizes_and_padding_border_margin(&containing_block_for_container.into())
.into();
let max_box_size = self
.config
.flex_axis
.vec2_to_flex_relative(sizes.content_max_box_size);
let min_box_size = self
.config
.flex_axis
.vec2_to_flex_relative(sizes.content_min_box_size.auto_is(Au::zero));
(
min_box_size,
max_box_size,
sizes.depends_on_block_constraints,
)
}
#[inline] #[inline]
pub(crate) fn layout_style(&self) -> LayoutStyle { pub(crate) fn layout_style(&self) -> LayoutStyle {
LayoutStyle::Default(&self.style) LayoutStyle::Default(&self.style)
@ -1206,7 +1180,9 @@ impl<'a> FlexItem<'a> {
let align_self = AlignItems(config.resolve_align_self_for_child(box_.style())); let align_self = AlignItems(config.resolve_align_self_for_child(box_.style()));
let (flex_base_size, flex_base_size_is_definite) = box_.flex_base_size( let (flex_base_size, flex_base_size_is_definite) = box_.flex_base_size(
flex_context.layout_context, flex_context.layout_context,
flex_context.container_definite_inner_size, flex_context
.container_inner_size_constraint
.map(|size| size.to_definite()),
cross_axis_is_item_block_axis, cross_axis_is_item_block_axis,
flex_relative_content_box_size, flex_relative_content_box_size,
flex_relative_content_min_size, flex_relative_content_min_size,
@ -1632,7 +1608,9 @@ impl InitialFlexLineLayout<'_> {
/// <https://drafts.csswg.org/css-flexbox/#algo-cross-line> /// <https://drafts.csswg.org/css-flexbox/#algo-cross-line>
fn cross_size<'items>(items: &'items [FlexLineItem<'items>], flex_context: &FlexContext) -> Au { fn cross_size<'items>(items: &'items [FlexLineItem<'items>], flex_context: &FlexContext) -> Au {
if flex_context.config.container_is_single_line { if flex_context.config.container_is_single_line {
if let Some(size) = flex_context.container_definite_inner_size.cross { if let SizeConstraint::Definite(size) =
flex_context.container_inner_size_constraint.cross
{
return size; return size;
} }
} }
@ -1662,13 +1640,11 @@ impl InitialFlexLineLayout<'_> {
// https://drafts.csswg.org/css-flexbox/#baseline-participation // https://drafts.csswg.org/css-flexbox/#baseline-participation
let largest = max_outer_hypothetical_cross_size.max(max_ascent + max_descent); let largest = max_outer_hypothetical_cross_size.max(max_ascent + max_descent);
if flex_context.config.container_is_single_line { match flex_context.container_inner_size_constraint.cross {
largest.clamp_between_extremums( SizeConstraint::MinMax(min, max) if flex_context.config.container_is_single_line => {
flex_context.container_min_cross_size, largest.clamp_between_extremums(min, max)
flex_context.container_max_cross_size, },
) _ => largest,
} else {
largest
} }
} }
@ -1953,7 +1929,10 @@ impl FlexItem<'_> {
// or the flex container has a definite main size. // or the flex container has a definite main size.
// <https://drafts.csswg.org/css-flexbox-1/#definite-sizes> // <https://drafts.csswg.org/css-flexbox-1/#definite-sizes>
if self.flex_base_size_is_definite || if self.flex_base_size_is_definite ||
flex_context.container_definite_inner_size.main.is_some() flex_context
.container_inner_size_constraint
.main
.is_definite()
{ {
SizeConstraint::Definite(used_main_size) SizeConstraint::Definite(used_main_size)
} else { } else {

1
components/layout_2020/formatting_contexts.rs
View file

@ -265,7 +265,6 @@ impl IndependentNonReplacedContents {
layout_context, layout_context,
positioning_context, positioning_context,
containing_block_for_children, containing_block_for_children,
containing_block,
), ),
IndependentNonReplacedContents::Grid(fc) => fc.layout( IndependentNonReplacedContents::Grid(fc) => fc.layout(
layout_context, layout_context,