use super::*;
use crate::layout::flex::estimate::constrain_flex_item_estimated_height;
use crate::units::{IntoLayoutLength, content_box_to_border_box_length};
pub(in crate::layout::flex) fn apply_main_axis_automatic_minimums(
items: &mut [FlexItemLayout],
estimates: &[FlexItemEstimate],
children: &[StyledChild<'_>],
container_style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> bool {
let mut changed = false;
let axes = PhysicalFlexDirection::new(physical_direction);
for ((item, estimate), child) in items.iter_mut().zip(estimates).zip(children) {
let Some(minimum) = automatic_minimum_main_size(
child,
estimate,
container_style,
physical_direction,
available,
) else {
continue;
};
let current = item.main_size(axes);
if current >= minimum {
continue;
}
if matches!(
physical_direction,
FlexDirection::RowReverse | FlexDirection::ColumnReverse
) {
item.set_main_start(axes, item.main_start(axes) - (minimum - current));
}
item.set_main_size(axes, minimum);
changed = true;
}
changed
}
pub(in crate::layout::flex) fn apply_non_negative_flex_item_content_box_minimums(
items: &mut [FlexItemLayout],
children: &[StyledChild<'_>],
) -> bool {
let mut changed = false;
for (item, child) in items.iter_mut().zip(children) {
let borders = used_border_widths(&child.style);
let min_width =
child.style.padding.left + child.style.padding.right + borders.left + borders.right;
if item.width() < FlexPhysicalHorizontalSize::new(min_width) {
item.set_width(FlexPhysicalHorizontalSize::new(min_width));
changed = true;
}
let min_height =
child.style.padding.top + child.style.padding.bottom + borders.top + borders.bottom;
if item.height() < FlexPhysicalVerticalSize::new(min_height) {
item.set_height(FlexPhysicalVerticalSize::new(min_height));
changed = true;
}
}
changed
}
pub(in crate::layout::flex) fn expand_flex_line_cross_bounds_for_item_overflow(
lines: &mut [FlexLineLayout],
items: &[FlexItemLayout],
children: &[StyledChild<'_>],
physical_direction: FlexDirection,
) {
for line in lines {
for &index in &line.item_indices {
let Some(item) = items.get(index) else {
continue;
};
let Some(child) = children.get(index) else {
continue;
};
let (cross_start, cross_end) =
item_outer_cross_bounds(item, &child.style, physical_direction);
line.cross_start = line.cross_start.min(cross_start);
line.cross_end = line.cross_end.max(cross_end);
}
}
}
pub(in crate::layout::flex) fn flex_item_estimate_available_space(
child_style: &ComputedStyle,
container_style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> FlexItemAvailableSpace {
let mut item_available = FlexItemAvailableSpace::from_container(available);
let horizontal_non_content =
child_style.padding.left + child_style.padding.right + horizontal_border_width(child_style);
if physical_direction.is_column_axis()
&& child_style
.box_values
.width
.length_if_no_percent()
.is_some()
&& let Some(width) = used_content_box_width_or_auto_with_basis(
child_style,
available.width_basis,
non_content_pt(horizontal_non_content),
)
{
item_available.set_definite_width(
PhysicalContentWidth::new(width),
FlexAvailableSizeSource::DefinitePreferredCrossSize,
);
}
let vertical_non_content =
child_style.padding.top + child_style.padding.bottom + vertical_border_width(child_style);
let preferred_height = used_content_box_height_or_auto_with_basis(
child_style,
available.height_basis,
non_content_pt(vertical_non_content),
);
let definite_height = preferred_height
.map(|height| {
(
height,
if physical_direction.is_column_axis() {
FlexAvailableSizeSource::DefinitePreferredMainSize
} else {
FlexAvailableSizeSource::DefinitePreferredCrossSize
},
)
})
.or_else(|| {
physical_direction
.is_column_axis()
.then(|| {
definite_post_flexing_main_size(child_style, physical_direction, available).map(
|height| {
(
content_box_pt(height.points()),
FlexAvailableSizeSource::DefiniteFlexBase,
)
},
)
})
.flatten()
});
if let Some((height, source)) = definite_height {
item_available.set_definite_height(PhysicalContentHeight::new(height), source);
}
let Some(premeasure_cross_size) = flex_item_premeasure_stretched_cross_size(
child_style,
container_style,
physical_direction,
available,
) else {
return item_available;
};
let stretched_cross_size = premeasure_cross_size.size();
item_available.set_definite_cross_size(
physical_direction,
stretched_cross_size,
premeasure_cross_size.available_size_source(),
);
item_available.set_stretched_cross_size(physical_direction, stretched_cross_size);
item_available
}
pub(in crate::layout::flex) fn stretched_flex_item_cross_size(
child_style: &ComputedStyle,
container_style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexCrossSize> {
if !matches!(
effective_align_self(child_style, container_style).keyword,
SelfAlignmentKeyword::Auto | SelfAlignmentKeyword::Normal | SelfAlignmentKeyword::Stretch
) || flex_item_has_auto_cross_margin(child_style, physical_direction)
{
return None;
}
if physical_direction.is_row_axis() {
if !child_style.box_values.height.is_auto() {
return None;
}
let container_cross_size =
balanced_flex_cross_measurement_size(container_style, physical_direction, available)?;
Some(
(container_cross_size
- FlexCrossLength::new(child_style.margin.top + child_style.margin.bottom))
.non_negative_size(),
)
} else {
if !child_style.box_values.width.is_auto() {
return None;
}
let container_cross_size =
balanced_flex_cross_measurement_size(container_style, physical_direction, available)?;
Some(
(container_cross_size
- FlexCrossLength::new(child_style.margin.left + child_style.margin.right))
.non_negative_size(),
)
}
}
pub(super) fn flex_item_premeasure_stretched_cross_size(
child_style: &ComputedStyle,
container_style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexPremeasureCrossSize> {
if !matches!(
effective_align_self(child_style, container_style).keyword,
SelfAlignmentKeyword::Auto | SelfAlignmentKeyword::Normal | SelfAlignmentKeyword::Stretch
) || flex_item_has_auto_cross_margin(child_style, physical_direction)
{
return None;
}
let container_cross_size = if container_style.flex_wrap.balances_lines()
&& container_style.flex_line_count.get() > 1
{
balanced_flex_cross_measurement_size(container_style, physical_direction, available)
.map(FlexPremeasureCrossSize::BalancedLineSlot)
} else if !container_style.flex_wrap.wraps() {
let size = if physical_direction.is_row_axis() {
flex_cross_size_from_content_box(available.height_basis_content_box_length()?)
} else {
flex_cross_size_from_content_box(available.width_basis_content_box_length()?)
};
Some(FlexPremeasureCrossSize::DefiniteSingleLineContainer(size))
} else {
None
}?;
let item_cross_size = if physical_direction.is_row_axis() {
if !child_style.box_values.height.is_auto() {
return None;
}
let stretch_size = (container_cross_size.size()
- FlexCrossLength::new(child_style.margin.top + child_style.margin.bottom))
.non_negative_size();
flex_cross_size_from_content_box(constrain_flex_item_estimated_height(
child_style,
flex_cross_content_box_length(stretch_size),
flex_cross_content_box_length(stretch_size),
flex_cross_content_box_length(stretch_size),
available.height_basis,
non_content_pt(
child_style.padding.top
+ child_style.padding.bottom
+ vertical_border_width(child_style),
),
))
} else {
if !child_style.box_values.width.is_auto() {
return None;
}
let stretch_size = (container_cross_size.size()
- FlexCrossLength::new(child_style.margin.left + child_style.margin.right))
.non_negative_size();
flex_cross_size_from_content_box(constrain_content_width(
child_style,
flex_cross_content_box_length(stretch_size),
available.width_basis,
))
};
Some(match container_cross_size {
FlexPremeasureCrossSize::BalancedLineSlot(_) => {
FlexPremeasureCrossSize::BalancedLineSlot(item_cross_size)
}
FlexPremeasureCrossSize::DefiniteSingleLineContainer(_) => {
FlexPremeasureCrossSize::DefiniteSingleLineContainer(item_cross_size)
}
})
}
fn balanced_flex_cross_measurement_size(
container_style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexCrossSize> {
let has_explicit_balanced_line_count =
container_style.flex_wrap.balances_lines() && container_style.flex_line_count.get() > 1;
if has_explicit_balanced_line_count {
return if physical_direction.is_row_axis() {
available
.height_constraint()
.map(|height| FlexCrossSize::new(height.points()))
} else {
Some(FlexCrossSize::new(available.width.points()))
};
}
available.definite_cross_size(physical_direction)
}
fn definite_flex_basis_main_size(
style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexMainSize> {
let css::ComputedFlexBasis::LengthPercentage(ref length) = style.flex_basis else {
return None;
};
used_length_percentage_or_auto_with_basis(
css::ComputedLengthPercentageOrAuto::LengthPercentage(length.value.clone()),
available.main_basis(physical_direction),
)
.map(flex_main_size_from_layout_extent)
}
pub(super) fn definite_post_flexing_main_size(
style: &ComputedStyle,
physical_direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexMainSize> {
definite_flex_basis_main_size(style, physical_direction, available).or_else(|| {
if !matches!(style.flex_basis, css::ComputedFlexBasis::Auto) {
return None;
}
if physical_direction.is_row_axis() {
used_content_box_width_or_auto_with_basis(
style,
available.width_basis,
non_content_pt(
style.padding.left + style.padding.right + horizontal_border_width(style),
),
)
.map(flex_main_size_from_content_box)
} else {
used_content_box_height_or_auto_with_basis(
style,
available.height_basis,
non_content_pt(
style.padding.top + style.padding.bottom + vertical_border_width(style),
),
)
.map(flex_main_size_from_content_box)
}
})
}
pub(in crate::layout::flex) fn automatic_minimum_main_content_size(
child: &StyledChild<'_>,
estimate: &FlexItemEstimate,
container_style: &ComputedStyle,
direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<ContentBoxLength> {
let child_style = &child.style;
let item_available =
flex_item_estimate_available_space(child_style, container_style, direction, available);
let stretched_cross_size = if direction.is_row_axis() {
item_available
.stretched_height
.map(PhysicalContentHeight::content_box_length)
.map(flex_cross_size_from_content_box)
} else {
item_available
.stretched_width
.map(PhysicalContentWidth::content_box_length)
.map(flex_cross_size_from_content_box)
};
let child_padding = flex_item_used_padding(child_style, container_style, available);
let child_margin = flex_item_used_margin(child_style, container_style, available);
let child_borders = used_border_widths(child_style);
let horizontal_stretch = FlexStretchFitContext {
available_margin_box_size: available
.width_basis_content_box_length()
.map(IntoLayoutLength::into_layout_length),
margin_size: layout_pt(child_margin.left + child_margin.right),
non_content_size: non_content_pt(
child_padding.left + child_padding.right + child_borders.left + child_borders.right,
),
box_sizing: child_style.box_sizing,
};
let vertical_stretch = FlexStretchFitContext {
available_margin_box_size: available
.height_basis_content_box_length()
.map(IntoLayoutLength::into_layout_length),
margin_size: layout_pt(child_margin.top + child_margin.bottom),
non_content_size: non_content_pt(
child_padding.top + child_padding.bottom + child_borders.top + child_borders.bottom,
),
box_sizing: child_style.box_sizing,
};
let (specified_min, percentage_basis, stretch, cross_stretch) = if direction.is_row_axis() {
(
child_style.box_values.min_width.clone(),
available.width_basis,
horizontal_stretch,
vertical_stretch,
)
} else {
(
child_style.box_values.min_height.clone(),
available.height_basis,
vertical_stretch,
horizontal_stretch,
)
};
resolve_automatic_flex_minimum(
specified_min,
FlexMinSizeDimensionContext {
style: child_style,
direction,
automatic_minimum_inputs: estimate.automatic_main_minimum_inputs,
available_cross_size: if direction.is_row_axis() {
available
.height_basis_content_box_length()
.map(flex_cross_size_from_content_box)
} else {
available
.width_basis_content_box_length()
.map(flex_cross_size_from_content_box)
},
cross_stretch,
stretched_cross_size,
is_main_axis: true,
overflow: flex_item_main_axis_overflow(child_style, direction),
percentage_basis,
stretch,
},
)
.map(|minimum| minimum.used_content_box)
}
pub(in crate::layout::flex) fn automatic_minimum_main_size(
child: &StyledChild<'_>,
estimate: &FlexItemEstimate,
container_style: &ComputedStyle,
direction: FlexDirection,
available: FlexAvailableSpace,
) -> Option<FlexMainSize> {
let child_style = &child.style;
let minimum = automatic_minimum_main_content_size(
child,
estimate,
container_style,
direction,
available,
)?;
let non_content = if direction.is_row_axis() {
child_style.padding.left + child_style.padding.right + horizontal_border_width(child_style)
} else {
child_style.padding.top + child_style.padding.bottom + vertical_border_width(child_style)
};
Some(flex_main_size_from_layout_extent(
content_box_to_border_box_length(minimum, non_content_pt(non_content)).into_layout_length(),
))
}