1use std::cell::{Cell, LazyCell};
6use std::cmp::Ordering;
7use std::sync::Arc;
8
9use app_units::Au;
10use atomic_refcell::AtomicRef;
11use itertools::izip;
12use rayon::iter::{
13 IndexedParallelIterator, IntoParallelIterator, ParallelDrainRange, ParallelIterator,
14};
15use style::Zero;
16use style::computed_values::position::T as Position;
17use style::logical_geometry::{LogicalAxis, WritingMode};
18use style::properties::ComputedValues;
19use style::properties::longhands::align_items::computed_value::T as AlignItems;
20use style::properties::longhands::box_sizing::computed_value::T as BoxSizing;
21use style::properties::longhands::flex_wrap::computed_value::T as FlexWrap;
22use style::values::computed::LengthPercentage;
23use style::values::generics::flex::GenericFlexBasis as FlexBasis;
24use style::values::generics::length::LengthPercentageOrNormal;
25use style::values::specified::align::AlignFlags;
26
27use super::geom::{FlexAxis, FlexRelativeRect, FlexRelativeSides, FlexRelativeVec2};
28use super::{FlexContainer, FlexContainerConfig, FlexItemBox, FlexLevelBox};
29use crate::cell::ArcRefCell;
30use crate::containing_block::{
31 ConstraintSpace, ContainingBlock, ContainingBlockSize, IndefiniteContainingBlock,
32};
33use crate::context::LayoutContext;
34use crate::dom::WeakLayoutBox;
35use crate::formatting_contexts::Baselines;
36use crate::fragment_tree::{
37 BoxFragment, CollapsedBlockMargins, Fragment, FragmentChildren, FragmentFlags,
38 SpecificLayoutInfo,
39};
40use crate::geom::{AuOrAuto, LogicalRect, LogicalSides, LogicalVec2};
41use crate::layout_box_base::IndependentFormattingContextLayoutResult;
42use crate::positioned::{
43 AbsolutelyPositionedBox, PositioningContext, PositioningContextLength, StaticPositionRect,
44 relative_adjustement,
45};
46use crate::sizing::{
47 ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult, IntrinsicSizingMode,
48 LazySize, Size, SizeConstraint, Sizes,
49};
50use crate::style_ext::{AspectRatio, Clamp, ComputedValuesExt, ContentBoxSizesAndPBM, LayoutStyle};
51
52struct FlexContext<'a> {
55 config: FlexContainerConfig,
56 layout_context: &'a LayoutContext<'a>,
57 containing_block: &'a ContainingBlock<'a>, container_inner_size_constraint: FlexRelativeVec2<SizeConstraint>,
59}
60
61struct FlexItem<'a> {
63 box_: &'a FlexItemBox,
64
65 content_cross_sizes: Sizes,
67
68 padding: FlexRelativeSides<Au>,
69 border: FlexRelativeSides<Au>,
70 margin: FlexRelativeSides<AuOrAuto>,
71
72 pbm_auto_is_zero: FlexRelativeVec2<Au>,
75
76 flex_base_size: Au,
78
79 flex_base_size_is_definite: bool,
83
84 hypothetical_main_size: Au,
86
87 content_min_main_size: Au,
90
91 content_max_main_size: Option<Au>,
94
95 align_self: AlignItems,
97
98 depends_on_block_constraints: bool,
100
101 preferred_aspect_ratio: Option<AspectRatio>,
103
104 automatic_cross_size: Size<Au>,
107 automatic_cross_size_for_intrinsic_sizing: Size<Au>,
108}
109
110enum FlexContent {
113 AbsolutelyPositionedBox(ArcRefCell<AbsolutelyPositionedBox>),
114 FlexItemPlaceholder,
115}
116
117struct FlexItemLayoutResult {
119 hypothetical_cross_size: Au,
120 fragments: FragmentChildren,
121 positioning_context: PositioningContext,
122
123 content_baselines_for_parent_relative_to_margin_box: Baselines,
126
127 flex_alignment_baseline_relative_to_margin_box: Option<Au>,
130
131 content_block_size: Au,
134
135 containing_block_size: ContainingBlockSize,
137
138 depends_on_block_constraints: bool,
140
141 specific_layout_info: Option<SpecificLayoutInfo>,
143}
144
145struct FlexLineItem<'a> {
148 item: FlexItem<'a>,
150
151 layout_result: FlexItemLayoutResult,
154
155 used_main_size: Au,
157}
158
159impl FlexLineItem<'_> {
160 fn get_or_synthesize_baseline_with_cross_size(
161 &self,
162 cross_size: Au,
163 flex_container_config: &FlexContainerConfig,
164 ) -> Au {
165 self.layout_result
166 .flex_alignment_baseline_relative_to_margin_box
167 .unwrap_or_else(|| {
168 self.item
169 .synthesized_baseline_relative_to_margin_box(cross_size, flex_container_config)
170 })
171 }
172
173 #[expect(clippy::too_many_arguments)]
174 fn collect_fragment(
175 mut self,
176 initial_flex_layout: &InitialFlexLineLayout,
177 item_used_size: FlexRelativeVec2<Au>,
178 item_margin: FlexRelativeSides<Au>,
179 item_main_interval: Au,
180 final_line_cross_size: Au,
181 shared_alignment_baseline: &Option<Au>,
182 flex_context: &mut FlexContext,
183 all_baselines: &mut Baselines,
184 main_position_cursor: &mut Au,
185 ) -> (Arc<BoxFragment>, PositioningContext) {
186 *main_position_cursor +=
189 item_margin.main_start + self.item.border.main_start + self.item.padding.main_start;
190 let item_content_main_start_position = *main_position_cursor;
191
192 *main_position_cursor += item_used_size.main +
193 self.item.padding.main_end +
194 self.item.border.main_end +
195 item_margin.main_end +
196 item_main_interval;
197
198 let item_content_cross_start_position = self.item.align_along_cross_axis(
200 &item_margin,
201 &item_used_size.cross,
202 final_line_cross_size,
203 self.layout_result
204 .flex_alignment_baseline_relative_to_margin_box
205 .unwrap_or_default(),
206 shared_alignment_baseline.unwrap_or_default(),
207 flex_context.config.flex_wrap_is_reversed,
208 );
209
210 let start_corner = FlexRelativeVec2 {
211 main: item_content_main_start_position,
212 cross: item_content_cross_start_position,
213 };
214
215 let final_line_size = FlexRelativeVec2 {
217 main: initial_flex_layout.line_size.main,
218 cross: final_line_cross_size,
219 };
220 let content_rect = flex_context.rect_to_flow_relative(
221 final_line_size,
222 FlexRelativeRect {
223 start_corner,
224 size: item_used_size,
225 },
226 );
227
228 let adjust_baseline = |baseline: Au| {
229 baseline + item_content_cross_start_position -
230 self.item.border.cross_start -
231 self.item.padding.cross_start -
232 item_margin.cross_start
233 };
234
235 let baselines = self
236 .layout_result
237 .content_baselines_for_parent_relative_to_margin_box;
238 if flex_context.config.flex_direction_is_reversed {
239 if let Some(last_baseline) = baselines.last {
240 all_baselines
241 .last
242 .get_or_insert_with(|| adjust_baseline(last_baseline));
243 }
244 if let Some(first_baseline) = baselines.first {
245 all_baselines.first = Some(adjust_baseline(first_baseline));
246 }
247 } else {
248 if let Some(first_baseline) = baselines.first {
249 all_baselines
250 .first
251 .get_or_insert_with(|| adjust_baseline(first_baseline));
252 }
253 if let Some(last_baseline) = baselines.last {
254 all_baselines.last = Some(adjust_baseline(last_baseline));
255 }
256 }
257
258 let mut fragment_info = self.item.box_.base_fragment_info();
259 fragment_info
260 .flags
261 .insert(FragmentFlags::IS_FLEX_OR_GRID_ITEM);
262 if self.item.depends_on_block_constraints {
263 fragment_info.flags.insert(
264 FragmentFlags::SIZE_DEPENDS_ON_BLOCK_CONSTRAINTS_AND_CAN_BE_CHILD_OF_FLEX_ITEM,
265 );
266 }
267 let flags = fragment_info.flags;
268
269 let containing_block = flex_context.containing_block;
270 let container_writing_mode = containing_block.style.writing_mode;
271 let style = self.item.box_.style();
272
273 let mut fragment = BoxFragment::new(
274 fragment_info,
275 style.clone(),
276 self.layout_result.fragments,
277 content_rect.as_physical_deprecated(flex_context.containing_block),
278 flex_context
279 .sides_to_flow_relative(self.item.padding)
280 .to_physical(container_writing_mode),
281 flex_context
282 .sides_to_flow_relative(self.item.border)
283 .to_physical(container_writing_mode),
284 flex_context
285 .sides_to_flow_relative(item_margin)
286 .to_physical(container_writing_mode),
287 self.layout_result.specific_layout_info,
288 );
289
290 if style.establishes_containing_block_for_absolute_descendants(flags) {
294 self.layout_result
295 .positioning_context
296 .layout_collected_children(flex_context.layout_context, &mut fragment);
297 }
298
299 if style.get_box().position == Position::Relative {
300 fragment.base.translate_rect(
301 relative_adjustement(style, containing_block)
302 .to_physical_size(containing_block.style.writing_mode),
303 );
304 }
305
306 let fragment = Arc::new(fragment);
307 self.item
308 .box_
309 .independent_formatting_context
310 .base
311 .set_fragment(Fragment::Box(fragment.clone()));
312 (fragment, self.layout_result.positioning_context)
313 }
314}
315
316struct FinalFlexLineLayout {
319 cross_size: Au,
321 item_fragments: Vec<(Arc<BoxFragment>, PositioningContext)>,
324 shared_alignment_baseline: Option<Au>,
327 all_baselines: Baselines,
332}
333
334impl FlexContainerConfig {
335 fn resolve_reversable_flex_alignment(
336 &self,
337 align_flags: AlignFlags,
338 reversed: bool,
339 ) -> AlignFlags {
340 match (align_flags.value(), reversed) {
341 (AlignFlags::FLEX_START, false) => AlignFlags::START | align_flags.flags(),
342 (AlignFlags::FLEX_START, true) => AlignFlags::END | align_flags.flags(),
343 (AlignFlags::FLEX_END, false) => AlignFlags::END | align_flags.flags(),
344 (AlignFlags::FLEX_END, true) => AlignFlags::START | align_flags.flags(),
345 (_, _) => align_flags,
346 }
347 }
348
349 fn resolve_align_self_for_child(&self, child_style: &ComputedValues) -> AlignFlags {
350 self.resolve_reversable_flex_alignment(
351 child_style
352 .resolve_align_self(self.align_items, AlignFlags::STRETCH)
353 .0,
354 self.flex_wrap_is_reversed,
355 )
356 }
357
358 fn resolve_justify_content_for_child(&self) -> AlignFlags {
359 self.resolve_reversable_flex_alignment(
360 self.justify_content.primary(),
361 self.flex_direction_is_reversed,
362 )
363 }
364
365 fn sides_to_flex_relative<T>(&self, sides: LogicalSides<T>) -> FlexRelativeSides<T> {
366 self.main_start_cross_start_sides_are
367 .sides_to_flex_relative(sides)
368 }
369
370 fn sides_to_flow_relative<T>(&self, sides: FlexRelativeSides<T>) -> LogicalSides<T> {
371 self.main_start_cross_start_sides_are
372 .sides_to_flow_relative(sides)
373 }
374}
375
376impl FlexContext<'_> {
377 #[inline]
378 fn sides_to_flow_relative<T>(&self, x: FlexRelativeSides<T>) -> LogicalSides<T> {
379 self.config.sides_to_flow_relative(x)
380 }
381
382 #[inline]
383 fn rect_to_flow_relative(
384 &self,
385 base_rect_size: FlexRelativeVec2<Au>,
386 rect: FlexRelativeRect<Au>,
387 ) -> LogicalRect<Au> {
388 super::geom::rect_to_flow_relative(
389 self.config.flex_axis,
390 self.config.main_start_cross_start_sides_are,
391 base_rect_size,
392 rect,
393 )
394 }
395}
396
397#[derive(Debug, Default)]
398struct DesiredFlexFractionAndGrowOrShrinkFactor {
399 desired_flex_fraction: f32,
400 flex_grow_or_shrink_factor: f32,
401}
402
403#[derive(Default)]
404struct FlexItemBoxInlineContentSizesInfo {
405 outer_flex_base_size: Au,
406 outer_min_main_size: Au,
407 outer_max_main_size: Option<Au>,
408 min_flex_factors: DesiredFlexFractionAndGrowOrShrinkFactor,
409 max_flex_factors: DesiredFlexFractionAndGrowOrShrinkFactor,
410 min_content_main_size_for_multiline_container: Au,
411 depends_on_block_constraints: bool,
412}
413
414impl ComputeInlineContentSizes for FlexContainer {
415 #[servo_tracing::instrument(name = "FlexContainer::compute_inline_content_sizes", skip_all)]
416 fn compute_inline_content_sizes(
417 &self,
418 layout_context: &LayoutContext,
419 constraint_space: &ConstraintSpace,
420 ) -> InlineContentSizesResult {
421 match self.config.flex_axis {
422 FlexAxis::Row => {
423 self.main_content_sizes(layout_context, &constraint_space.into(), || {
424 unreachable!(
425 "Unexpected FlexContext query during row flex intrinsic size calculation."
426 )
427 })
428 },
429 FlexAxis::Column => self.cross_content_sizes(layout_context, &constraint_space.into()),
430 }
431 }
432}
433
434impl FlexContainer {
435 fn cross_content_sizes(
436 &self,
437 layout_context: &LayoutContext,
438 containing_block_for_children: &IndefiniteContainingBlock,
439 ) -> InlineContentSizesResult {
440 assert_eq!(
442 self.config.flex_axis,
443 FlexAxis::Column,
444 "The cross axis should be the inline one"
445 );
446 let mut sizes = ContentSizes::zero();
447 let mut depends_on_block_constraints = false;
448 for kid in self.children.iter() {
449 let kid = &*kid.borrow();
450 match kid {
451 FlexLevelBox::FlexItem(item) => {
452 let ifc = &item.independent_formatting_context;
456 let result = ifc.outer_inline_content_sizes(
457 layout_context,
458 containing_block_for_children,
459 &LogicalVec2::zero(),
460 false, false, );
463 sizes.max_assign(result.sizes);
464 depends_on_block_constraints |= result.depends_on_block_constraints;
465 },
466 FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(_) => {},
467 }
468 }
469 InlineContentSizesResult {
470 sizes,
471 depends_on_block_constraints,
472 }
473 }
474
475 fn main_content_sizes<'a>(
476 &self,
477 layout_context: &LayoutContext,
478 containing_block_for_children: &IndefiniteContainingBlock,
479 flex_context_getter: impl Fn() -> &'a FlexContext<'a>,
480 ) -> InlineContentSizesResult {
481 let mut chosen_max_flex_fraction = f32::NEG_INFINITY;
490 let mut chosen_min_flex_fraction = f32::NEG_INFINITY;
491 let mut sum_of_flex_grow_factors = 0.0;
492 let mut sum_of_flex_shrink_factors = 0.0;
493 let mut item_infos = vec![];
494
495 for kid in self.children.iter() {
496 let kid = &*kid.borrow();
497 match kid {
498 FlexLevelBox::FlexItem(item) => {
499 sum_of_flex_grow_factors += item.style().get_position().flex_grow.0;
500 sum_of_flex_shrink_factors += item.style().get_position().flex_shrink.0;
501
502 let info = item.main_content_size_info(
503 layout_context,
504 containing_block_for_children,
505 &self.config,
506 &flex_context_getter,
507 );
508
509 chosen_max_flex_fraction =
514 chosen_max_flex_fraction.max(info.max_flex_factors.desired_flex_fraction);
515 chosen_min_flex_fraction =
516 chosen_min_flex_fraction.max(info.min_flex_factors.desired_flex_fraction);
517
518 item_infos.push(info)
519 },
520 FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(_) => {},
521 }
522 }
523
524 let normalize_flex_fraction = |chosen_flex_fraction| {
525 if chosen_flex_fraction > 0.0 && sum_of_flex_grow_factors < 1.0 {
526 chosen_flex_fraction / sum_of_flex_grow_factors
530 } else if chosen_flex_fraction < 0.0 && sum_of_flex_shrink_factors < 1.0 {
531 chosen_flex_fraction * sum_of_flex_shrink_factors
535 } else {
536 chosen_flex_fraction
537 }
538 };
539
540 let chosen_min_flex_fraction = normalize_flex_fraction(chosen_min_flex_fraction);
541 let chosen_max_flex_fraction = normalize_flex_fraction(chosen_max_flex_fraction);
542
543 let main_gap = match self.config.flex_axis {
544 FlexAxis::Row => self.style.get_column_gap(),
545 FlexAxis::Column => self.style.get_row_gap(),
546 };
547 let main_gap = match main_gap {
548 LengthPercentageOrNormal::LengthPercentage(length_percentage) => {
549 length_percentage.to_used_value(Au::zero())
550 },
551 LengthPercentageOrNormal::Normal => Au::zero(),
552 };
553 let extra_space_from_main_gap = main_gap * (item_infos.len() as i32 - 1);
554 let mut container_max_content_size = extra_space_from_main_gap;
555 let mut container_min_content_size = if self.config.flex_wrap == FlexWrap::NOWRAP {
556 extra_space_from_main_gap
557 } else {
558 Au::zero()
559 };
560 let mut container_depends_on_block_constraints = false;
561
562 for FlexItemBoxInlineContentSizesInfo {
563 outer_flex_base_size,
564 outer_min_main_size,
565 outer_max_main_size,
566 min_flex_factors,
567 max_flex_factors,
568 min_content_main_size_for_multiline_container,
569 depends_on_block_constraints,
570 } in item_infos.iter()
571 {
572 container_max_content_size += (*outer_flex_base_size +
578 Au::from_f32_px(
579 max_flex_factors.flex_grow_or_shrink_factor * chosen_max_flex_fraction,
580 ))
581 .clamp_between_extremums(*outer_min_main_size, *outer_max_main_size);
582
583 if self.config.flex_wrap == FlexWrap::NOWRAP {
594 container_min_content_size += (*outer_flex_base_size +
595 Au::from_f32_px(
596 min_flex_factors.flex_grow_or_shrink_factor * chosen_min_flex_fraction,
597 ))
598 .clamp_between_extremums(*outer_min_main_size, *outer_max_main_size);
599 } else {
600 container_min_content_size
601 .max_assign(*min_content_main_size_for_multiline_container);
602 }
603
604 container_depends_on_block_constraints |= depends_on_block_constraints;
605 }
606
607 InlineContentSizesResult {
608 sizes: ContentSizes {
609 min_content: container_min_content_size,
610 max_content: container_max_content_size,
611 },
612 depends_on_block_constraints: container_depends_on_block_constraints,
613 }
614 }
615
616 #[servo_tracing::instrument(
618 name = "FlexContainer::layout",
619 skip_all,
620 fields(self_address = self as *const _ as usize)
621 )]
622 pub(crate) fn layout(
623 &self,
624 layout_context: &LayoutContext,
625 positioning_context: &mut PositioningContext,
626 containing_block: &ContainingBlock,
627 lazy_block_size: &LazySize,
628 ) -> IndependentFormattingContextLayoutResult {
629 debug_assert!(!containing_block.has_quirky_block_size());
630 let mut flex_context = FlexContext {
631 config: self.config.clone(),
632 layout_context,
633 containing_block,
634 container_inner_size_constraint: self.config.flex_axis.vec2_to_flex_relative(
636 LogicalVec2 {
637 inline: SizeConstraint::Definite(containing_block.inline_size()),
638 block: containing_block.maybe_quirky_block_size(),
639 },
640 ),
641 };
642
643 let container_main_size = match self.config.flex_axis {
646 FlexAxis::Row => containing_block.inline_size(),
647 FlexAxis::Column => lazy_block_size.resolve(|| {
648 let mut containing_block = IndefiniteContainingBlock::from(containing_block);
649 containing_block.size.maybe_quirky_block_size = None;
650 self.main_content_sizes(layout_context, &containing_block, || &flex_context)
651 .sizes
652 .max_content
653 }),
654 };
655
656 let mut flex_items = Vec::with_capacity(self.children.len());
658
659 let absolutely_positioned_items_with_original_order = self
667 .children
668 .iter()
669 .map(|arcrefcell| {
670 let borrowed = arcrefcell.borrow();
671 match &*borrowed {
672 FlexLevelBox::OutOfFlowAbsolutelyPositionedBox(absolutely_positioned) => {
673 FlexContent::AbsolutelyPositionedBox(absolutely_positioned.clone())
674 },
675 FlexLevelBox::FlexItem(_) => {
676 let item = AtomicRef::map(borrowed, |child| match child {
677 FlexLevelBox::FlexItem(item) => item,
678 _ => unreachable!(),
679 });
680 flex_items.push(item);
681 FlexContent::FlexItemPlaceholder
682 },
683 }
684 })
685 .collect::<Vec<_>>();
686
687 let row_gap = self.style.get_row_gap();
688 let column_gap = self.style.get_column_gap();
689 let (cross_gap, main_gap) = match flex_context.config.flex_axis {
690 FlexAxis::Row => (row_gap, column_gap),
691 FlexAxis::Column => (column_gap, row_gap),
692 };
693 let cross_gap = match cross_gap {
694 LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
695 .maybe_to_used_value(
696 flex_context
697 .container_inner_size_constraint
698 .cross
699 .to_definite(),
700 )
701 .unwrap_or_default(),
702 LengthPercentageOrNormal::Normal => Au::zero(),
703 };
704 let main_gap = match main_gap {
705 LengthPercentageOrNormal::LengthPercentage(length_percent) => length_percent
706 .maybe_to_used_value(
707 flex_context
708 .container_inner_size_constraint
709 .main
710 .to_definite(),
711 )
712 .unwrap_or_default(),
713 LengthPercentageOrNormal::Normal => Au::zero(),
714 };
715
716 let initial_line_layouts = do_initial_flex_line_layout(
719 &mut flex_context,
720 container_main_size,
721 &flex_items,
722 main_gap,
723 );
724
725 let line_count = initial_line_layouts.len();
726 let content_cross_size = initial_line_layouts
727 .iter()
728 .map(|layout| layout.line_size.cross)
729 .sum::<Au>() +
730 cross_gap * (line_count as i32 - 1);
731 let content_block_size = match self.config.flex_axis {
732 FlexAxis::Row => content_cross_size,
733 FlexAxis::Column => container_main_size,
734 };
735
736 let container_cross_size = match self.config.flex_axis {
738 FlexAxis::Row => lazy_block_size.resolve(|| content_cross_size),
739 FlexAxis::Column => containing_block.inline_size(),
740 };
741
742 let container_size = FlexRelativeVec2 {
743 main: container_main_size,
744 cross: container_cross_size,
745 };
746
747 let mut remaining_free_cross_space = container_cross_size - content_cross_size;
748
749 let num_lines = initial_line_layouts.len();
754 let resolved_align_content: AlignFlags = {
755 let align_content_style = flex_context.config.align_content.primary();
757 let mut is_safe = align_content_style.flags() == AlignFlags::SAFE;
758
759 let mut resolved_align_content = match align_content_style.value() {
762 AlignFlags::NORMAL => AlignFlags::STRETCH,
763 align_content => align_content,
764 };
765
766 let fallback_is_needed = match resolved_align_content {
774 _ if remaining_free_cross_space <= Au::zero() => true,
775 AlignFlags::STRETCH => num_lines < 1,
776 AlignFlags::SPACE_BETWEEN | AlignFlags::SPACE_AROUND | AlignFlags::SPACE_EVENLY => {
777 num_lines < 2
778 },
779 _ => false,
780 };
781
782 if fallback_is_needed {
783 (resolved_align_content, is_safe) = match resolved_align_content {
784 AlignFlags::STRETCH => (AlignFlags::FLEX_START, false),
785 AlignFlags::SPACE_BETWEEN => (AlignFlags::FLEX_START, true),
786 AlignFlags::SPACE_AROUND => (AlignFlags::CENTER, true),
787 AlignFlags::SPACE_EVENLY => (AlignFlags::CENTER, true),
788 _ => (resolved_align_content, is_safe),
789 }
790 };
791
792 if remaining_free_cross_space <= Au::zero() && is_safe {
794 resolved_align_content = AlignFlags::START;
795 }
796
797 resolved_align_content
798 };
799
800 let flex_wrap_is_reversed = flex_context.config.flex_wrap_is_reversed;
802 let resolved_align_content = self
803 .config
804 .resolve_reversable_flex_alignment(resolved_align_content, flex_wrap_is_reversed);
805 let mut cross_start_position_cursor = match resolved_align_content {
806 AlignFlags::START if flex_wrap_is_reversed => remaining_free_cross_space,
807 AlignFlags::START => Au::zero(),
808 AlignFlags::END if flex_wrap_is_reversed => Au::zero(),
809 AlignFlags::END => remaining_free_cross_space,
810 AlignFlags::CENTER => remaining_free_cross_space / 2,
811 AlignFlags::STRETCH => Au::zero(),
812 AlignFlags::SPACE_BETWEEN => Au::zero(),
813 AlignFlags::SPACE_AROUND => remaining_free_cross_space / num_lines as i32 / 2,
814 AlignFlags::SPACE_EVENLY => remaining_free_cross_space / (num_lines as i32 + 1),
815
816 _ => Au::zero(),
818 };
819
820 let inline_axis_is_main_axis = self.config.flex_axis == FlexAxis::Row;
821 let mut baseline_alignment_participating_baselines = Baselines::default();
822 let mut all_baselines = Baselines::default();
823 let mut flex_item_fragments = initial_line_layouts.into_iter().enumerate().flat_map(
824 |(index, initial_line_layout)| {
825 let (space_to_add_to_line, space_to_add_after_line) =
829 allocate_free_cross_space_for_flex_line(
830 resolved_align_content,
831 remaining_free_cross_space,
832 (num_lines - index) as i32,
833 );
834 remaining_free_cross_space -= space_to_add_to_line + space_to_add_after_line;
835
836 let final_line_cross_size =
837 initial_line_layout.line_size.cross + space_to_add_to_line;
838 let mut final_line_layout = initial_line_layout.finish_with_final_cross_size(
839 &mut flex_context,
840 main_gap,
841 final_line_cross_size,
842 );
843
844 let line_cross_start_position = cross_start_position_cursor;
845 cross_start_position_cursor = line_cross_start_position +
846 final_line_cross_size +
847 space_to_add_after_line +
848 cross_gap;
849
850 let flow_relative_line_position =
851 match (self.config.flex_axis, flex_wrap_is_reversed) {
852 (FlexAxis::Row, false) => LogicalVec2 {
853 block: line_cross_start_position,
854 inline: Au::zero(),
855 },
856 (FlexAxis::Row, true) => LogicalVec2 {
857 block: container_cross_size -
858 line_cross_start_position -
859 final_line_layout.cross_size,
860 inline: Au::zero(),
861 },
862 (FlexAxis::Column, false) => LogicalVec2 {
863 block: Au::zero(),
864 inline: line_cross_start_position,
865 },
866 (FlexAxis::Column, true) => LogicalVec2 {
867 block: Au::zero(),
868 inline: container_cross_size -
869 line_cross_start_position -
870 final_line_cross_size,
871 },
872 };
873
874 if inline_axis_is_main_axis {
875 let line_shared_alignment_baseline = final_line_layout
876 .shared_alignment_baseline
877 .map(|baseline| baseline + flow_relative_line_position.block);
878 if index == 0 {
879 baseline_alignment_participating_baselines.first =
880 line_shared_alignment_baseline;
881 }
882 if index == num_lines - 1 {
883 baseline_alignment_participating_baselines.last =
884 line_shared_alignment_baseline;
885 }
886 }
887
888 let line_all_baselines = final_line_layout
889 .all_baselines
890 .offset(flow_relative_line_position.block);
891 if index == 0 {
892 all_baselines.first = line_all_baselines.first;
893 }
894 if index == num_lines - 1 {
895 all_baselines.last = line_all_baselines.last;
896 }
897
898 let physical_line_position =
899 flow_relative_line_position.to_physical_size(self.style.writing_mode);
900 for (fragment, _) in &mut final_line_layout.item_fragments {
901 fragment.base.translate_rect(physical_line_position);
902 }
903 final_line_layout.item_fragments
904 },
905 );
906
907 let flex_container_size = LogicalVec2 {
908 inline: containing_block.inline_size(),
909 block: content_block_size,
910 };
911 let fragments = absolutely_positioned_items_with_original_order
912 .into_iter()
913 .map(|child_as_abspos| match child_as_abspos {
914 FlexContent::AbsolutelyPositionedBox(absolutely_positioned_box) => self
915 .create_absolutely_positioned_flex_child_fragment(
916 absolutely_positioned_box,
917 container_size,
918 positioning_context,
919 ),
920 FlexContent::FlexItemPlaceholder => {
921 let (fragment, mut child_positioning_context) =
924 flex_item_fragments.next().unwrap();
925 child_positioning_context.adjust_static_position_of_hoisted_fragments(
926 &LogicalRect::from_physical(
927 fragment.base.rect(),
928 self.style.writing_mode,
929 flex_container_size,
930 ),
931 self.style.writing_mode,
932 PositioningContextLength::zero(),
933 );
934 positioning_context.append(child_positioning_context);
935 Fragment::Box(fragment)
936 },
937 })
938 .collect::<Vec<_>>();
939
940 assert!(flex_item_fragments.next().is_none());
942
943 let baselines = Baselines {
944 first: baseline_alignment_participating_baselines
945 .first
946 .or(all_baselines.first),
947 last: baseline_alignment_participating_baselines
948 .last
949 .or(all_baselines.last),
950 };
951
952 let depends_on_block_constraints = true;
965
966 IndependentFormattingContextLayoutResult {
967 fragments: FragmentChildren::PhysicalDeprecated(fragments),
968 content_block_size,
969 content_inline_size_for_table: None,
970 baselines,
971 depends_on_block_constraints,
972 specific_layout_info: None,
973 collapsible_margins_in_children: CollapsedBlockMargins::zero(),
974 }
975 }
976
977 fn create_absolutely_positioned_flex_child_fragment(
993 &self,
994 absolutely_positioned_box: ArcRefCell<AbsolutelyPositionedBox>,
995 container_size: FlexRelativeVec2<Au>,
996 positioning_context: &mut PositioningContext,
997 ) -> Fragment {
998 let alignment = {
999 let fragment = absolutely_positioned_box.borrow();
1000 let make_flex_only_values_directional_for_absolutes =
1001 |value: AlignFlags, reversed: bool| match (value.value(), reversed) {
1002 (AlignFlags::NORMAL | AlignFlags::AUTO | AlignFlags::STRETCH, true) => {
1003 AlignFlags::END
1004 },
1005 (AlignFlags::STRETCH, false) => AlignFlags::START,
1006 (AlignFlags::SPACE_BETWEEN, false) => AlignFlags::START,
1007 (AlignFlags::SPACE_BETWEEN, true) => AlignFlags::END,
1008 _ => value,
1009 };
1010 let cross = make_flex_only_values_directional_for_absolutes(
1011 self.config
1012 .resolve_align_self_for_child(fragment.context.style()),
1013 self.config.flex_wrap_is_reversed,
1014 );
1015 let main = make_flex_only_values_directional_for_absolutes(
1016 self.config.resolve_justify_content_for_child(),
1017 self.config.flex_direction_is_reversed,
1018 );
1019
1020 FlexRelativeVec2 { cross, main }
1021 };
1022 let logical_alignment = self.config.flex_axis.vec2_to_flow_relative(alignment);
1023
1024 let static_position_rect = LogicalRect {
1025 start_corner: LogicalVec2::zero(),
1026 size: self.config.flex_axis.vec2_to_flow_relative(container_size),
1027 };
1028
1029 let hoisted_box = AbsolutelyPositionedBox::to_hoisted(
1030 absolutely_positioned_box,
1031 StaticPositionRect::new(static_position_rect, self.style.writing_mode),
1032 logical_alignment,
1033 self.config.writing_mode,
1034 );
1035 let hoisted_fragment = hoisted_box.fragment.clone();
1036 positioning_context.push(hoisted_box);
1037 Fragment::AbsoluteOrFixedPositionedPlaceholder(hoisted_fragment)
1038 }
1039
1040 #[inline]
1041 pub(crate) fn layout_style(&self) -> LayoutStyle<'_> {
1042 LayoutStyle::Default(&self.style)
1043 }
1044
1045 pub(crate) fn attached_to_tree(&self, layout_box: WeakLayoutBox) {
1046 for child in &self.children {
1047 child.borrow_mut().with_base_mut(|base| {
1048 base.parent_box.replace(layout_box.clone());
1049 });
1050 }
1051 }
1052}
1053
1054fn allocate_free_cross_space_for_flex_line(
1058 resolved_align_content: AlignFlags,
1059 remaining_free_cross_space: Au,
1060 remaining_line_count: i32,
1061) -> (Au, Au) {
1062 if remaining_free_cross_space.is_zero() {
1063 return (Au::zero(), Au::zero());
1064 }
1065
1066 match resolved_align_content {
1067 AlignFlags::START => (Au::zero(), Au::zero()),
1068 AlignFlags::FLEX_START => (Au::zero(), Au::zero()),
1069 AlignFlags::END => (Au::zero(), Au::zero()),
1070 AlignFlags::FLEX_END => (Au::zero(), Au::zero()),
1071 AlignFlags::CENTER => (Au::zero(), Au::zero()),
1072 AlignFlags::STRETCH => (
1073 remaining_free_cross_space / remaining_line_count,
1074 Au::zero(),
1075 ),
1076 AlignFlags::SPACE_BETWEEN => {
1077 if remaining_line_count > 1 {
1078 (
1079 Au::zero(),
1080 remaining_free_cross_space / (remaining_line_count - 1),
1081 )
1082 } else {
1083 (Au::zero(), Au::zero())
1084 }
1085 },
1086 AlignFlags::SPACE_AROUND => (
1087 Au::zero(),
1088 remaining_free_cross_space / remaining_line_count,
1089 ),
1090 AlignFlags::SPACE_EVENLY => (
1091 Au::zero(),
1092 remaining_free_cross_space / (remaining_line_count + 1),
1093 ),
1094
1095 _ => (Au::zero(), Au::zero()),
1097 }
1098}
1099
1100impl<'a> FlexItem<'a> {
1101 fn new(flex_context: &FlexContext, box_: &'a FlexItemBox) -> Self {
1102 let containing_block = IndefiniteContainingBlock::from(flex_context.containing_block);
1103 let content_box_sizes_and_pbm = box_
1104 .independent_formatting_context
1105 .layout_style()
1106 .content_box_sizes_and_padding_border_margin(&containing_block);
1107 box_.to_flex_item(
1108 flex_context.layout_context,
1109 &containing_block,
1110 &content_box_sizes_and_pbm,
1111 &flex_context.config,
1112 &|| flex_context,
1113 )
1114 }
1115}
1116
1117fn cross_axis_is_item_block_axis(
1118 container_is_horizontal: bool,
1119 item_is_horizontal: bool,
1120 flex_axis: FlexAxis,
1121) -> bool {
1122 let item_is_orthogonal = item_is_horizontal != container_is_horizontal;
1123 let container_is_row = flex_axis == FlexAxis::Row;
1124
1125 container_is_row ^ item_is_orthogonal
1126}
1127
1128fn item_with_auto_cross_size_stretches_to_line_size(
1132 align_self: AlignItems,
1133 margin: &FlexRelativeSides<AuOrAuto>,
1134) -> bool {
1135 align_self.0.value() == AlignFlags::STRETCH &&
1136 !margin.cross_start.is_auto() &&
1137 !margin.cross_end.is_auto()
1138}
1139
1140fn do_initial_flex_line_layout<'items>(
1143 flex_context: &mut FlexContext,
1144 container_main_size: Au,
1145 flex_item_boxes: &'items Vec<AtomicRef<'items, FlexItemBox>>,
1146 main_gap: Au,
1147) -> Vec<InitialFlexLineLayout<'items>> {
1148 let construct_line = |items: Vec<FlexItem<'items>>| {
1149 InitialFlexLineLayout::new(flex_context, items, container_main_size, main_gap)
1150 };
1151
1152 if flex_context.config.container_is_single_line {
1153 let items: Vec<_> = flex_item_boxes
1154 .iter()
1155 .map(|item_box| FlexItem::new(flex_context, item_box))
1156 .collect();
1157 return vec![construct_line(items)];
1158 }
1159
1160 let mut lines = Vec::new();
1161 let mut line_items = Vec::new();
1162 let mut line_size_so_far = Au::zero();
1163
1164 for item_box in flex_item_boxes {
1165 let item = FlexItem::new(flex_context, item_box);
1166 let item_size = item.hypothetical_main_size + item.pbm_auto_is_zero.main;
1167
1168 let mut line_size_would_be = line_size_so_far + item_size;
1170 if !line_items.is_empty() {
1171 line_size_would_be += main_gap;
1172 }
1173
1174 let item_fits = line_size_would_be <= container_main_size;
1175 if item_fits || line_items.is_empty() {
1176 line_items.push(item);
1177 line_size_so_far = line_size_would_be;
1178 } else {
1179 lines.push(std::mem::take(&mut line_items));
1180 line_items.push(item);
1181 line_size_so_far = item_size;
1182 }
1183 }
1184
1185 lines.push(line_items);
1187
1188 let job_sizes = lines
1189 .iter()
1190 .map(|line| line.iter().map(FlexItem::subtree_size).sum());
1191 if flex_context
1192 .layout_context
1193 .should_parallelize_layout(job_sizes)
1194 {
1195 lines.par_drain(..).map(construct_line).collect()
1196 } else {
1197 lines.into_iter().map(construct_line).collect()
1198 }
1199}
1200
1201struct InitialFlexLineLayout<'a> {
1205 items: Vec<FlexLineItem<'a>>,
1207
1208 line_size: FlexRelativeVec2<Au>,
1210
1211 free_space_in_main_axis: Au,
1213}
1214
1215impl InitialFlexLineLayout<'_> {
1216 fn new<'items>(
1217 flex_context: &FlexContext,
1218 items: Vec<FlexItem<'items>>,
1219 container_main_size: Au,
1220 main_gap: Au,
1221 ) -> InitialFlexLineLayout<'items> {
1222 let item_count = items.len();
1223 let (item_used_main_sizes, free_space_in_main_axis) = Self::resolve_flexible_lengths(
1224 &items,
1225 container_main_size - main_gap * (item_count as i32 - 1),
1226 );
1227
1228 let line_cross_size_before_layout = Self::cross_size_before_layout(flex_context);
1234 let layout_item = |(item, used_main_size): (FlexItem<'items>, Au)| {
1235 let used_cross_size = line_cross_size_before_layout.and_then(|line_cross_size| {
1236 item.used_cross_size_before_layout(flex_context, used_main_size, line_cross_size)
1237 });
1238 let layout_result = item.layout(used_main_size, flex_context, used_cross_size);
1239 FlexLineItem {
1240 item,
1241 layout_result,
1242 used_main_size,
1243 }
1244 };
1245 let items: Vec<_> = if flex_context
1246 .layout_context
1247 .should_parallelize_layout(items.iter().map(FlexItem::subtree_size))
1248 {
1249 items
1250 .into_par_iter()
1251 .zip(item_used_main_sizes.into_par_iter())
1252 .map(layout_item)
1253 .collect()
1254 } else {
1255 items
1256 .into_iter()
1257 .zip(item_used_main_sizes)
1258 .map(layout_item)
1259 .collect()
1260 };
1261
1262 let line_cross_size = Self::cross_size(&items, flex_context);
1264 let line_size = FlexRelativeVec2 {
1265 main: container_main_size,
1266 cross: line_cross_size,
1267 };
1268
1269 InitialFlexLineLayout {
1270 items,
1271 line_size,
1272 free_space_in_main_axis,
1273 }
1274 }
1275
1276 fn resolve_flexible_lengths<'items>(
1279 items: &'items [FlexItem<'items>],
1280 container_main_size: Au,
1281 ) -> (Vec<Au>, Au) {
1282 struct FlexibleLengthResolutionItem<'items> {
1283 item: &'items FlexItem<'items>,
1284 frozen: Cell<bool>,
1285 target_main_size: Cell<Au>,
1286 flex_factor: f32,
1287 min_max_violation_kind: Cell<Ordering>,
1288 }
1289
1290 let outer_hypothetical_main_sizes_sum: Au = items
1295 .iter()
1296 .map(|item| item.hypothetical_main_size + item.pbm_auto_is_zero.main)
1297 .sum();
1298 let grow = outer_hypothetical_main_sizes_sum < container_main_size;
1299
1300 let mut frozen_count = 0;
1301 let items: Vec<_> = items
1302 .iter()
1303 .map(|item| {
1304 let target_main_size = Cell::new(item.flex_base_size);
1307
1308 let flex_factor = if grow {
1315 item.box_.style().get_position().flex_grow.0
1316 } else {
1317 item.box_.style().get_position().flex_shrink.0
1318 };
1319
1320 let is_inflexible = flex_factor == 0. ||
1321 if grow {
1322 item.flex_base_size > item.hypothetical_main_size
1323 } else {
1324 item.flex_base_size < item.hypothetical_main_size
1325 };
1326
1327 let frozen = Cell::new(false);
1328 if is_inflexible {
1329 frozen_count += 1;
1330 frozen.set(true);
1331 target_main_size.set(item.hypothetical_main_size);
1332 }
1333
1334 FlexibleLengthResolutionItem {
1335 item,
1336 frozen,
1337 target_main_size,
1338 flex_factor,
1339 min_max_violation_kind: Cell::new(Ordering::Equal),
1341 }
1342 })
1343 .collect();
1344
1345 let unfrozen_items = || items.iter().filter(|item| !item.frozen.get());
1346 let main_sizes = |items: Vec<FlexibleLengthResolutionItem>| {
1347 items
1348 .into_iter()
1349 .map(|item| item.target_main_size.get())
1350 .collect()
1351 };
1352
1353 let free_space = |all_items_frozen| {
1358 let items_size = items
1359 .iter()
1360 .map(|item| {
1361 item.item.pbm_auto_is_zero.main +
1362 if all_items_frozen || item.frozen.get() {
1363 item.target_main_size.get()
1364 } else {
1365 item.item.flex_base_size
1366 }
1367 })
1368 .sum();
1369 container_main_size - items_size
1370 };
1371
1372 let initial_free_space = free_space(false);
1373 loop {
1374 let mut remaining_free_space = free_space(false);
1376 if frozen_count >= items.len() {
1379 return (main_sizes(items), remaining_free_space);
1380 }
1381
1382 let unfrozen_items_flex_factor_sum =
1388 unfrozen_items().map(|item| item.flex_factor).sum();
1389 if unfrozen_items_flex_factor_sum < 1. {
1390 let multiplied = initial_free_space.scale_by(unfrozen_items_flex_factor_sum);
1391 if multiplied.abs() < remaining_free_space.abs() {
1392 remaining_free_space = multiplied
1393 }
1394 }
1395
1396 if !remaining_free_space.is_zero() {
1402 if grow {
1408 for item in unfrozen_items() {
1409 let ratio = item.flex_factor / unfrozen_items_flex_factor_sum;
1410 item.target_main_size
1411 .set(item.item.flex_base_size + remaining_free_space.scale_by(ratio));
1412 }
1413 } else {
1422 let scaled_shrink_factor = |item: &FlexibleLengthResolutionItem| {
1424 item.item.flex_base_size.scale_by(item.flex_factor)
1425 };
1426 let scaled_shrink_factors_sum: Au =
1427 unfrozen_items().map(scaled_shrink_factor).sum();
1428 if scaled_shrink_factors_sum > Au::zero() {
1429 for item in unfrozen_items() {
1430 let ratio = scaled_shrink_factor(item).0 as f32 /
1431 scaled_shrink_factors_sum.0 as f32;
1432 item.target_main_size.set(
1433 item.item.flex_base_size -
1434 remaining_free_space.abs().scale_by(ratio),
1435 );
1436 }
1437 }
1438 }
1439 }
1440
1441 let mut total_violation = Au::zero();
1447 for item in unfrozen_items() {
1448 let unclamped = item.target_main_size.get();
1449 let clamped = unclamped.clamp_between_extremums(
1450 item.item.content_min_main_size,
1451 item.item.content_max_main_size,
1452 );
1453 item.target_main_size.set(clamped);
1454 item.min_max_violation_kind.set(clamped.cmp(&unclamped));
1457 total_violation += clamped - unclamped;
1458 }
1459
1460 match total_violation.cmp(&Au::zero()) {
1467 Ordering::Equal => {
1468 let remaining_free_space = free_space(true);
1471 return (main_sizes(items), remaining_free_space);
1472 },
1473 total_violation_kind => {
1474 for item in unfrozen_items() {
1475 if item.min_max_violation_kind.get() == total_violation_kind {
1476 item.frozen.set(true);
1477 frozen_count += 1;
1478 }
1479 }
1480 },
1481 }
1482 }
1483 }
1484
1485 fn cross_size_before_layout(flex_context: &FlexContext) -> Option<Au> {
1489 flex_context
1490 .container_inner_size_constraint
1491 .cross
1492 .to_definite()
1493 .filter(|_| flex_context.config.container_is_single_line)
1494 }
1495
1496 fn cross_size<'items>(items: &'items [FlexLineItem<'items>], flex_context: &FlexContext) -> Au {
1498 if let Some(size) = Self::cross_size_before_layout(flex_context) {
1499 return size;
1500 }
1501
1502 let mut max_ascent = Au::zero();
1503 let mut max_descent = Au::zero();
1504 let mut max_outer_hypothetical_cross_size = Au::zero();
1505 for item in items.iter() {
1506 if matches!(
1508 item.item.align_self.0.value(),
1509 AlignFlags::BASELINE | AlignFlags::LAST_BASELINE
1510 ) {
1511 let baseline = item.get_or_synthesize_baseline_with_cross_size(
1512 item.layout_result.hypothetical_cross_size,
1513 &flex_context.config,
1514 );
1515 let hypothetical_margin_box_cross_size =
1516 item.layout_result.hypothetical_cross_size + item.item.pbm_auto_is_zero.cross;
1517 max_ascent = max_ascent.max(baseline);
1518 max_descent = max_descent.max(hypothetical_margin_box_cross_size - baseline);
1519 } else {
1520 max_outer_hypothetical_cross_size = max_outer_hypothetical_cross_size.max(
1521 item.layout_result.hypothetical_cross_size + item.item.pbm_auto_is_zero.cross,
1522 );
1523 }
1524 }
1525
1526 let largest = max_outer_hypothetical_cross_size.max(max_ascent + max_descent);
1528 match flex_context.container_inner_size_constraint.cross {
1529 SizeConstraint::MinMax(min, max) if flex_context.config.container_is_single_line => {
1530 largest.clamp_between_extremums(min, max)
1531 },
1532 _ => largest,
1533 }
1534 }
1535
1536 fn finish_with_final_cross_size(
1537 mut self,
1538 flex_context: &mut FlexContext,
1539 main_gap: Au,
1540 final_line_cross_size: Au,
1541 ) -> FinalFlexLineLayout {
1542 let auto_margins_count = self
1550 .items
1551 .iter()
1552 .map(|item| {
1553 item.item.margin.main_start.is_auto() as u32 +
1554 item.item.margin.main_end.is_auto() as u32
1555 })
1556 .sum::<u32>();
1557 let (space_distributed_to_auto_main_margins, free_space_in_main_axis) =
1558 if self.free_space_in_main_axis > Au::zero() && auto_margins_count > 0 {
1559 (
1560 self.free_space_in_main_axis / auto_margins_count as i32,
1561 Au::zero(),
1562 )
1563 } else {
1564 (Au::zero(), self.free_space_in_main_axis)
1565 };
1566
1567 let item_count = self.items.len();
1570 let mut shared_alignment_baseline = None;
1571 let mut item_used_cross_sizes = Vec::with_capacity(item_count);
1572 let mut item_margins = Vec::with_capacity(item_count);
1573 for item in self.items.iter_mut() {
1574 let cross_axis = match flex_context.config.flex_axis {
1575 FlexAxis::Row => LogicalAxis::Block,
1576 FlexAxis::Column => LogicalAxis::Inline,
1577 };
1578 let layout = &mut item.layout_result;
1579 let get_content_size = || match cross_axis {
1580 LogicalAxis::Block => layout.content_block_size.into(),
1581 LogicalAxis::Inline => item
1582 .item
1583 .inline_content_sizes(flex_context, item.used_main_size),
1584 };
1585 let used_cross_size =
1586 item.item
1587 .used_cross_size(cross_axis, final_line_cross_size, get_content_size);
1588 item_used_cross_sizes.push(used_cross_size);
1589
1590 let needs_new_layout = match cross_axis {
1597 LogicalAxis::Block => {
1598 (match item.item.content_cross_sizes.preferred {
1599 Size::Initial => item.item.automatic_cross_size == Size::Stretch,
1600 Size::Stretch => true,
1601 _ => false,
1602 }) && Some(used_cross_size) != layout.containing_block_size.block_size() &&
1603 layout.depends_on_block_constraints
1604 },
1605 LogicalAxis::Inline => used_cross_size != layout.containing_block_size.inline_size,
1606 };
1607 if needs_new_layout {
1608 #[cfg(feature = "tracing")]
1609 tracing::warn!(
1610 name: "Flex item stretch cache miss",
1611 cached_inline = ?layout.containing_block_size.inline_size,
1612 cached_block = ?layout.containing_block_size.block_size(),
1613 required_cross_size = ?used_cross_size,
1614 cross_axis = ?cross_axis,
1615 depends_on_block_constraints = layout.depends_on_block_constraints,
1616 );
1617 *layout =
1618 item.item
1619 .layout(item.used_main_size, flex_context, Some(used_cross_size));
1620 }
1621
1622 let baseline = item
1623 .get_or_synthesize_baseline_with_cross_size(used_cross_size, &flex_context.config);
1624 if matches!(
1625 item.item.align_self.0.value(),
1626 AlignFlags::BASELINE | AlignFlags::LAST_BASELINE
1627 ) {
1628 shared_alignment_baseline =
1629 Some(shared_alignment_baseline.unwrap_or(baseline).max(baseline));
1630 }
1631 item.layout_result
1632 .flex_alignment_baseline_relative_to_margin_box = Some(baseline);
1633
1634 item_margins.push(item.item.resolve_auto_margins(
1635 flex_context,
1636 final_line_cross_size,
1637 used_cross_size,
1638 space_distributed_to_auto_main_margins,
1639 ));
1640 }
1641
1642 let resolved_justify_content: AlignFlags = {
1648 let justify_content_style = flex_context.config.justify_content.primary();
1649
1650 let inline_axis_is_main_axis = flex_context.config.flex_axis == FlexAxis::Row;
1652 let line_left_is_inline_start =
1653 flex_context.config.writing_mode.line_left_is_inline_start();
1654 let mut resolved_justify_content = match justify_content_style.value() {
1655 AlignFlags::LEFT if inline_axis_is_main_axis => {
1658 if line_left_is_inline_start {
1659 AlignFlags::FLEX_START
1660 } else {
1661 AlignFlags::FLEX_END
1662 }
1663 },
1664 AlignFlags::RIGHT if inline_axis_is_main_axis => {
1666 if line_left_is_inline_start {
1667 AlignFlags::FLEX_END
1668 } else {
1669 AlignFlags::FLEX_START
1670 }
1671 },
1672 AlignFlags::LEFT | AlignFlags::RIGHT => AlignFlags::FLEX_START,
1675 justify_content => justify_content,
1676 };
1677 let mut is_safe = justify_content_style.flags() == AlignFlags::SAFE;
1678
1679 if item_count <= 1 || free_space_in_main_axis <= Au::zero() {
1684 (resolved_justify_content, is_safe) = match resolved_justify_content {
1685 AlignFlags::STRETCH => (AlignFlags::FLEX_START, true),
1686 AlignFlags::SPACE_BETWEEN => (AlignFlags::FLEX_START, true),
1687 AlignFlags::SPACE_AROUND => (AlignFlags::CENTER, true),
1688 AlignFlags::SPACE_EVENLY => (AlignFlags::CENTER, true),
1689 _ => (resolved_justify_content, is_safe),
1690 }
1691 };
1692
1693 if free_space_in_main_axis <= Au::zero() && is_safe {
1695 resolved_justify_content = AlignFlags::START;
1696 }
1697
1698 resolved_justify_content
1699 };
1700
1701 let main_start_position = match resolved_justify_content {
1703 AlignFlags::START => Au::zero(),
1704 AlignFlags::FLEX_START => {
1705 if flex_context.config.flex_direction_is_reversed {
1706 free_space_in_main_axis
1707 } else {
1708 Au::zero()
1709 }
1710 },
1711 AlignFlags::END => free_space_in_main_axis,
1712 AlignFlags::FLEX_END => {
1713 if flex_context.config.flex_direction_is_reversed {
1714 Au::zero()
1715 } else {
1716 free_space_in_main_axis
1717 }
1718 },
1719 AlignFlags::CENTER => free_space_in_main_axis / 2,
1720 AlignFlags::STRETCH => Au::zero(),
1721 AlignFlags::SPACE_BETWEEN => Au::zero(),
1722 AlignFlags::SPACE_AROUND => (free_space_in_main_axis / item_count as i32) / 2,
1723 AlignFlags::SPACE_EVENLY => free_space_in_main_axis / (item_count + 1) as i32,
1724
1725 _ => Au::zero(),
1727 };
1728
1729 let item_main_interval = match resolved_justify_content {
1730 AlignFlags::START => Au::zero(),
1731 AlignFlags::FLEX_START => Au::zero(),
1732 AlignFlags::END => Au::zero(),
1733 AlignFlags::FLEX_END => Au::zero(),
1734 AlignFlags::CENTER => Au::zero(),
1735 AlignFlags::STRETCH => Au::zero(),
1736 AlignFlags::SPACE_BETWEEN => free_space_in_main_axis / (item_count - 1) as i32,
1737 AlignFlags::SPACE_AROUND => free_space_in_main_axis / item_count as i32,
1738 AlignFlags::SPACE_EVENLY => free_space_in_main_axis / (item_count + 1) as i32,
1739
1740 _ => Au::zero(),
1742 };
1743 let item_main_interval = item_main_interval + main_gap;
1744
1745 let mut all_baselines = Baselines::default();
1746 let mut main_position_cursor = main_start_position;
1747
1748 let items = std::mem::take(&mut self.items);
1749 let item_fragments = izip!(items, item_margins, item_used_cross_sizes.iter())
1750 .map(|(item, item_margin, item_used_cross_size)| {
1751 let item_used_size = FlexRelativeVec2 {
1752 main: item.used_main_size,
1753 cross: *item_used_cross_size,
1754 };
1755 item.collect_fragment(
1756 &self,
1757 item_used_size,
1758 item_margin,
1759 item_main_interval,
1760 final_line_cross_size,
1761 &shared_alignment_baseline,
1762 flex_context,
1763 &mut all_baselines,
1764 &mut main_position_cursor,
1765 )
1766 })
1767 .collect();
1768
1769 FinalFlexLineLayout {
1770 cross_size: final_line_cross_size,
1771 item_fragments,
1772 all_baselines,
1773 shared_alignment_baseline,
1774 }
1775 }
1776}
1777
1778impl FlexItem<'_> {
1779 #[servo_tracing::instrument(
1784 name = "FlexItem::layout",
1785 skip_all,
1786 fields(
1787 self_address = self as *const _ as usize,
1788 box_address = self.box_ as *const _ as usize,
1789 )
1790 )]
1791
1792 fn layout(
1793 &self,
1794 used_main_size: Au,
1795 flex_context: &FlexContext,
1796 used_cross_size_override: Option<Au>,
1797 ) -> FlexItemLayoutResult {
1798 let containing_block = flex_context.containing_block;
1799 let independent_formatting_context = &self.box_.independent_formatting_context;
1800 let is_table = independent_formatting_context.is_table();
1801 let mut positioning_context = PositioningContext::default();
1802 let item_writing_mode = independent_formatting_context.style().writing_mode;
1803 let item_is_horizontal = item_writing_mode.is_horizontal();
1804 let flex_axis = flex_context.config.flex_axis;
1805 let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis(
1806 containing_block.style.writing_mode.is_horizontal(),
1807 item_is_horizontal,
1808 flex_axis,
1809 );
1810
1811 let (inline_size, block_size) = if cross_axis_is_item_block_axis {
1812 let cross_size = match used_cross_size_override {
1813 Some(s) => SizeConstraint::Definite(s),
1814 None => {
1815 let inline_stretch_size =
1816 containing_block.inline_stretch_size(self.pbm_auto_is_zero.main);
1817 let block_stretch_size =
1818 containing_block.block_stretch_size(self.pbm_auto_is_zero.cross);
1819 let tentative_block_content_size = independent_formatting_context
1820 .tentative_block_content_size(
1821 self.preferred_aspect_ratio,
1822 inline_stretch_size,
1823 );
1824 if let Some(block_content_size) = tentative_block_content_size {
1825 SizeConstraint::Definite(self.content_cross_sizes.resolve(
1826 LogicalAxis::Block,
1827 Size::FitContent,
1828 Au::zero,
1829 block_stretch_size,
1830 || block_content_size,
1831 is_table,
1832 ))
1833 } else {
1834 self.content_cross_sizes.resolve_extrinsic(
1835 Size::FitContent,
1836 Au::zero(),
1837 block_stretch_size,
1838 )
1839 }
1840 },
1841 };
1842 (used_main_size, cross_size)
1843 } else {
1844 let cross_size = used_cross_size_override.unwrap_or_else(|| {
1845 let stretch_size =
1846 containing_block.inline_stretch_size(self.pbm_auto_is_zero.cross);
1847 self.content_cross_sizes.resolve(
1848 LogicalAxis::Inline,
1849 Size::FitContent,
1850 Au::zero,
1851 stretch_size,
1852 || self.inline_content_sizes(flex_context, used_main_size),
1853 is_table,
1854 )
1855 });
1856 let is_grid = self.box_.independent_formatting_context.is_grid();
1865 let main_size = if is_grid ||
1866 self.flex_base_size_is_definite ||
1867 flex_context
1868 .container_inner_size_constraint
1869 .main
1870 .is_definite()
1871 {
1872 SizeConstraint::Definite(used_main_size)
1873 } else {
1874 SizeConstraint::MinMax(self.content_min_main_size, self.content_max_main_size)
1875 };
1876 (cross_size, main_size)
1877 };
1878
1879 let item_style = independent_formatting_context.style();
1880 let item_as_containing_block = ContainingBlock {
1881 size: ContainingBlockSize::new(inline_size, block_size),
1882 style: item_style,
1883 };
1884
1885 let lazy_block_size = if !cross_axis_is_item_block_axis {
1886 used_main_size.into()
1887 } else if let Some(cross_size) = used_cross_size_override {
1888 cross_size.into()
1889 } else {
1890 let stretch_size = containing_block.block_stretch_size(self.pbm_auto_is_zero.cross);
1891 LazySize::new(
1892 &self.content_cross_sizes,
1893 LogicalAxis::Block,
1894 Size::FitContent,
1895 Au::zero,
1896 stretch_size,
1897 is_table,
1898 )
1899 };
1900
1901 let layout = independent_formatting_context.layout(
1902 flex_context.layout_context,
1903 &mut positioning_context,
1904 &item_as_containing_block,
1905 containing_block,
1906 self.preferred_aspect_ratio,
1907 &lazy_block_size,
1908 );
1909 let IndependentFormattingContextLayoutResult {
1910 fragments,
1911 content_block_size,
1912 baselines: content_box_baselines,
1913 depends_on_block_constraints,
1914 specific_layout_info,
1915 ..
1916 } = layout;
1917
1918 let hypothetical_cross_size = if cross_axis_is_item_block_axis {
1919 lazy_block_size.resolve(|| content_block_size)
1920 } else {
1921 inline_size
1922 };
1923
1924 let item_inline_axis_is_horizontal = item_style.writing_mode.is_horizontal();
1925 let container_inline_axis_is_horizontal = flex_context.config.writing_mode.is_horizontal();
1926 let container_main_axis_is_horizontal = match flex_axis {
1927 FlexAxis::Row => container_inline_axis_is_horizontal,
1928 FlexAxis::Column => !container_inline_axis_is_horizontal,
1929 };
1930 let item_inline_axis_parallel_to_container_inline_axis =
1931 item_inline_axis_is_horizontal == container_inline_axis_is_horizontal;
1932 let item_inline_axis_parallel_to_container_main_axis =
1933 item_inline_axis_is_horizontal == container_main_axis_is_horizontal;
1934
1935 let content_baselines_relative_to_margin_box = content_box_baselines.offset(
1936 self.margin.cross_start.auto_is(Au::zero) +
1937 self.padding.cross_start +
1938 self.border.cross_start,
1939 );
1940
1941 let content_baselines_for_parent_relative_to_margin_box =
1942 if item_inline_axis_parallel_to_container_inline_axis {
1943 content_baselines_relative_to_margin_box
1944 } else {
1945 Baselines::default()
1946 };
1947
1948 let flex_alignment_baseline_relative_to_margin_box =
1949 if item_inline_axis_parallel_to_container_main_axis {
1950 match self.align_self.0.value() {
1951 AlignFlags::BASELINE => content_baselines_relative_to_margin_box.first,
1953 AlignFlags::LAST_BASELINE => content_baselines_relative_to_margin_box.last,
1954 _ => None,
1955 }
1956 } else {
1957 None
1958 };
1959
1960 FlexItemLayoutResult {
1961 hypothetical_cross_size,
1962 fragments,
1963 positioning_context,
1964 content_baselines_for_parent_relative_to_margin_box,
1965 flex_alignment_baseline_relative_to_margin_box,
1966 content_block_size,
1967 containing_block_size: item_as_containing_block.size,
1968 depends_on_block_constraints,
1969 specific_layout_info,
1970 }
1971 }
1972
1973 fn synthesized_baseline_relative_to_margin_box(
1976 &self,
1977 content_size: Au,
1978 config: &FlexContainerConfig,
1979 ) -> Au {
1980 let own_writing_mode = self.box_.style().writing_mode;
1981 let distance_from_cross_start_to_line_under = |writing_mode: WritingMode| -> Au {
1990 let line_under_edge_is_on_same_side_as_cross_start = (writing_mode.is_horizontal() &&
1995 config.flex_wrap_is_reversed) ||
1996 (writing_mode.is_vertical_lr() != config.flex_wrap_is_reversed);
1997 if line_under_edge_is_on_same_side_as_cross_start {
1998 self.margin.cross_start.auto_is(Au::zero)
2004 } else {
2005 content_size +
2011 self.margin.cross_start.auto_is(Au::zero) +
2012 self.padding.cross_sum() +
2013 self.border.cross_sum()
2014 }
2015 };
2016
2017 let block_flow_direction_is_orthogonal_to_main_axis = |writing_mode: WritingMode| {
2028 writing_mode.is_vertical() != (config.flex_axis == FlexAxis::Row)
2029 };
2030 if block_flow_direction_is_orthogonal_to_main_axis(own_writing_mode) {
2031 distance_from_cross_start_to_line_under(own_writing_mode)
2032 } else if block_flow_direction_is_orthogonal_to_main_axis(config.writing_mode) {
2033 distance_from_cross_start_to_line_under(config.writing_mode)
2034 } else if own_writing_mode.is_vertical() {
2035 distance_from_cross_start_to_line_under(WritingMode::WRITING_MODE_HORIZONTAL_TB)
2036 } else {
2037 let used_writing_mode = match own_writing_mode.is_bidi_ltr() {
2038 true => WritingMode::WRITING_MODE_VERTICAL_LR,
2039 false => WritingMode::WRITING_MODE_VERTICAL_RL,
2040 };
2041
2042 distance_from_cross_start_to_line_under(used_writing_mode)
2043 }
2044 }
2045
2046 fn subtree_size(&self) -> usize {
2047 self.box_.independent_formatting_context.subtree_size()
2048 }
2049
2050 fn resolve_auto_margins(
2056 &self,
2057 flex_context: &FlexContext,
2058 line_cross_size: Au,
2059 item_cross_content_size: Au,
2060 space_distributed_to_auto_main_margins: Au,
2061 ) -> FlexRelativeSides<Au> {
2062 let main_start = self
2063 .margin
2064 .main_start
2065 .auto_is(|| space_distributed_to_auto_main_margins);
2066 let main_end = self
2067 .margin
2068 .main_end
2069 .auto_is(|| space_distributed_to_auto_main_margins);
2070
2071 let auto_count = match (self.margin.cross_start, self.margin.cross_end) {
2072 (AuOrAuto::LengthPercentage(cross_start), AuOrAuto::LengthPercentage(cross_end)) => {
2073 return FlexRelativeSides {
2074 cross_start,
2075 cross_end,
2076 main_start,
2077 main_end,
2078 };
2079 },
2080 (AuOrAuto::Auto, AuOrAuto::Auto) => 2,
2081 _ => 1,
2082 };
2083 let outer_cross_size = self.pbm_auto_is_zero.cross + item_cross_content_size;
2084 let available = line_cross_size - outer_cross_size;
2085 let cross_start;
2086 let cross_end;
2087 if available > Au::zero() {
2088 let each_auto_margin = available / auto_count;
2089 cross_start = self.margin.cross_start.auto_is(|| each_auto_margin);
2090 cross_end = self.margin.cross_end.auto_is(|| each_auto_margin);
2091 } else {
2092 let flex_wrap = flex_context.containing_block.style.get_position().flex_wrap;
2105 let flex_wrap_reverse = match flex_wrap {
2106 FlexWrap::NOWRAP | FlexWrap::WRAP => false,
2107 FlexWrap::WRAP_REVERSE => true,
2108 _ => unreachable!("FlexWrap::BALANCE should be disabled"),
2109 };
2110 if flex_wrap_reverse {
2114 cross_start = self.margin.cross_start.auto_is(|| available);
2115 cross_end = self.margin.cross_end.auto_is(Au::zero);
2116 } else {
2117 cross_start = self.margin.cross_start.auto_is(Au::zero);
2118 cross_end = self.margin.cross_end.auto_is(|| available);
2119 }
2120 }
2121
2122 FlexRelativeSides {
2123 cross_start,
2124 cross_end,
2125 main_start,
2126 main_end,
2127 }
2128 }
2129
2130 fn align_along_cross_axis(
2132 &self,
2133 margin: &FlexRelativeSides<Au>,
2134 used_cross_size: &Au,
2135 line_cross_size: Au,
2136 propagated_baseline: Au,
2137 max_propagated_baseline: Au,
2138 wrap_reverse: bool,
2139 ) -> Au {
2140 let ending_alignment = line_cross_size - *used_cross_size - self.pbm_auto_is_zero.cross;
2141 let outer_cross_start =
2142 if self.margin.cross_start.is_auto() || self.margin.cross_end.is_auto() {
2143 Au::zero()
2144 } else {
2145 match self.align_self.0.value() {
2146 AlignFlags::STRETCH => Au::zero(),
2147 AlignFlags::CENTER => ending_alignment / 2,
2148 AlignFlags::BASELINE | AlignFlags::LAST_BASELINE => {
2149 max_propagated_baseline - propagated_baseline
2150 },
2151 AlignFlags::START => {
2152 if !wrap_reverse {
2153 Au::zero()
2154 } else {
2155 ending_alignment
2156 }
2157 },
2158 AlignFlags::END => {
2159 if !wrap_reverse {
2160 ending_alignment
2161 } else {
2162 Au::zero()
2163 }
2164 },
2165 _ => Au::zero(),
2166 }
2167 };
2168 outer_cross_start + margin.cross_start + self.border.cross_start + self.padding.cross_start
2169 }
2170
2171 #[inline]
2172 fn inline_content_sizes(&self, flex_context: &FlexContext, block_size: Au) -> ContentSizes {
2173 self.box_.inline_content_sizes(
2174 flex_context,
2175 SizeConstraint::Definite(block_size),
2176 self.preferred_aspect_ratio,
2177 )
2178 }
2179
2180 fn used_cross_size(
2183 &self,
2184 cross_axis: LogicalAxis,
2185 line_cross_size: Au,
2186 get_content_size: impl FnOnce() -> ContentSizes,
2187 ) -> Au {
2188 self.content_cross_sizes.resolve(
2189 cross_axis,
2190 self.automatic_cross_size,
2191 Au::zero,
2192 Some(Au::zero().max(line_cross_size - self.pbm_auto_is_zero.cross)),
2193 get_content_size,
2194 self.box_.independent_formatting_context.is_table() &&
2199 cross_axis == LogicalAxis::Inline,
2200 )
2201 }
2202
2203 fn used_cross_size_before_layout(
2206 &self,
2207 flex_context: &FlexContext,
2208 used_main_size: Au,
2209 line_cross_size: Au,
2210 ) -> Option<Au> {
2211 match flex_context.config.flex_axis {
2212 FlexAxis::Column => Some(self.used_cross_size(
2213 LogicalAxis::Inline,
2214 line_cross_size,
2215 || self.inline_content_sizes(flex_context, used_main_size),
2216 )),
2217 FlexAxis::Row => {
2221 let mut needs_content_size = false;
2222 let used_cross_size =
2223 self.used_cross_size(LogicalAxis::Block, line_cross_size, || {
2224 needs_content_size = true;
2225 ContentSizes::default()
2226 });
2227 (!needs_content_size).then_some(used_cross_size)
2228 },
2229 }
2230 }
2231}
2232
2233impl FlexItemBox {
2234 fn to_flex_item<'a>(
2235 &self,
2236 layout_context: &LayoutContext,
2237 containing_block: &IndefiniteContainingBlock,
2238 content_box_sizes_and_pbm: &ContentBoxSizesAndPBM,
2239 config: &FlexContainerConfig,
2240 flex_context_getter: &impl Fn() -> &'a FlexContext<'a>,
2241 ) -> FlexItem<'_> {
2242 let flex_axis = config.flex_axis;
2243 let style = self.style();
2244 let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis(
2245 containing_block.style.writing_mode.is_horizontal(),
2246 style.writing_mode.is_horizontal(),
2247 flex_axis,
2248 );
2249 let main_axis = if cross_axis_is_item_block_axis {
2250 LogicalAxis::Inline
2251 } else {
2252 LogicalAxis::Block
2253 };
2254 let align_self = AlignItems(config.resolve_align_self_for_child(style));
2255
2256 let ContentBoxSizesAndPBM {
2257 content_box_sizes,
2258 pbm,
2259 depends_on_block_constraints,
2260 preferred_size_computes_to_auto,
2261 } = content_box_sizes_and_pbm;
2262
2263 let preferred_aspect_ratio = self
2264 .independent_formatting_context
2265 .preferred_aspect_ratio(&pbm.padding_border_sums);
2266 let padding = config.sides_to_flex_relative(pbm.padding);
2267 let border = config.sides_to_flex_relative(pbm.border);
2268 let margin = config.sides_to_flex_relative(pbm.margin);
2269 let padding_border = padding.sum_by_axis() + border.sum_by_axis();
2270 let margin_auto_is_zero = config.sides_to_flex_relative(pbm.margin.auto_is(Au::zero));
2271 let pbm_auto_is_zero = FlexRelativeVec2 {
2272 main: padding_border.main,
2273 cross: padding_border.cross,
2274 } + margin_auto_is_zero.sum_by_axis();
2275 let (content_main_sizes, content_cross_sizes, cross_size_computes_to_auto) = match flex_axis
2276 {
2277 FlexAxis::Row => (
2278 &content_box_sizes.inline,
2279 &content_box_sizes.block,
2280 preferred_size_computes_to_auto.block,
2281 ),
2282 FlexAxis::Column => (
2283 &content_box_sizes.block,
2284 &content_box_sizes.inline,
2285 preferred_size_computes_to_auto.inline,
2286 ),
2287 };
2288 let automatic_cross_size = if cross_size_computes_to_auto &&
2289 item_with_auto_cross_size_stretches_to_line_size(align_self, &margin)
2290 {
2291 Size::Stretch
2292 } else {
2293 Size::FitContent
2294 };
2295 let automatic_cross_size_for_intrinsic_sizing = if config.container_is_single_line {
2296 automatic_cross_size
2297 } else {
2298 Size::FitContent
2299 };
2300 debug_assert!(!containing_block.has_quirky_block_size());
2301 let containing_block_size =
2302 flex_axis.vec2_to_flex_relative(containing_block.size.as_logical_vec2());
2303 let stretch_size = FlexRelativeVec2 {
2304 main: containing_block_size
2305 .main
2306 .map(|v| Au::zero().max(v - pbm_auto_is_zero.main)),
2307 cross: containing_block_size
2308 .cross
2309 .map(|v| Au::zero().max(v - pbm_auto_is_zero.cross)),
2310 };
2311
2312 let is_table = self.independent_formatting_context.is_table();
2313 let tentative_cross_content_size = if cross_axis_is_item_block_axis {
2314 self.independent_formatting_context
2315 .tentative_block_content_size(preferred_aspect_ratio, stretch_size.main)
2316 } else {
2317 None
2318 };
2319 let (preferred_cross_size, min_cross_size, max_cross_size) =
2320 if let Some(cross_content_size) = tentative_cross_content_size {
2321 let (preferred, min, max) = content_cross_sizes.resolve_each(
2322 automatic_cross_size_for_intrinsic_sizing,
2323 Au::zero,
2324 stretch_size.cross,
2325 || cross_content_size,
2326 is_table,
2327 );
2328 (Some(preferred), min, max)
2329 } else {
2330 content_cross_sizes.resolve_each_extrinsic(
2331 automatic_cross_size_for_intrinsic_sizing,
2332 Au::zero(),
2333 stretch_size.cross,
2334 )
2335 };
2336 let cross_size = SizeConstraint::new(preferred_cross_size, min_cross_size, max_cross_size);
2337
2338 let transferred_size_suggestion =
2343 LazyCell::new(|| match (preferred_aspect_ratio, cross_size) {
2344 (Some(ratio), SizeConstraint::Definite(cross_size)) => {
2345 Some(ratio.compute_dependent_size(main_axis, cross_size))
2346 },
2347 _ => None,
2348 });
2349
2350 let flex_base_size_is_definite = Cell::new(true);
2352 let main_content_sizes = LazyCell::new(|| {
2353 let flex_item = &self.independent_formatting_context;
2354 if let Some(transferred_size_suggestion) = *transferred_size_suggestion {
2360 return transferred_size_suggestion.into();
2361 }
2362
2363 flex_base_size_is_definite.set(false);
2364
2365 if cross_axis_is_item_block_axis {
2374 let constraint_space =
2377 ConstraintSpace::new(cross_size, style, preferred_aspect_ratio);
2378 let content_sizes = flex_item
2379 .inline_content_sizes(layout_context, &constraint_space)
2380 .sizes;
2381 if let Some(ratio) = preferred_aspect_ratio {
2382 let transferred_min = ratio.compute_dependent_size(main_axis, min_cross_size);
2383 let transferred_max =
2384 max_cross_size.map(|v| ratio.compute_dependent_size(main_axis, v));
2385 content_sizes
2386 .map(|size| size.clamp_between_extremums(transferred_min, transferred_max))
2387 } else {
2388 content_sizes
2389 }
2390 } else {
2391 self.layout_for_block_content_size(
2392 flex_context_getter(),
2393 &pbm_auto_is_zero,
2394 content_box_sizes,
2395 preferred_aspect_ratio,
2396 automatic_cross_size_for_intrinsic_sizing,
2397 IntrinsicSizingMode::Size,
2398 )
2399 .into()
2400 }
2401 });
2402
2403 let flex_base_size = self
2404 .flex_basis(
2405 containing_block_size.main,
2406 content_main_sizes.preferred,
2407 padding_border.main,
2408 )
2409 .resolve_for_preferred(Size::MaxContent, stretch_size.main, &main_content_sizes);
2410 let flex_base_size_is_definite = flex_base_size_is_definite.take();
2411
2412 let content_max_main_size = content_main_sizes
2413 .max
2414 .resolve_for_max(stretch_size.main, &main_content_sizes);
2415
2416 let get_automatic_minimum_size = || {
2417 if style.establishes_scroll_container(self.base_fragment_info().flags) {
2419 return Au::zero();
2420 }
2421
2422 let specified_size_suggestion = content_main_sizes
2426 .preferred
2427 .maybe_resolve_extrinsic(stretch_size.main);
2428
2429 let is_replaced = self.independent_formatting_context.is_replaced();
2430
2431 let content_size_suggestion = match preferred_aspect_ratio {
2436 Some(ratio) => main_content_sizes.min_content.clamp_between_extremums(
2437 ratio.compute_dependent_size(main_axis, min_cross_size),
2438 max_cross_size.map(|l| ratio.compute_dependent_size(main_axis, l)),
2439 ),
2440 None => main_content_sizes.min_content,
2441 };
2442
2443 match (specified_size_suggestion, *transferred_size_suggestion) {
2450 (Some(specified), _) => specified.min(content_size_suggestion),
2451 (_, Some(transferred)) if is_replaced => transferred.min(content_size_suggestion),
2452 _ => content_size_suggestion,
2453 }
2454 .clamp_below_max(content_max_main_size)
2455 };
2456 let content_min_main_size = content_main_sizes.min.resolve_for_min(
2457 get_automatic_minimum_size,
2458 stretch_size.main,
2459 &main_content_sizes,
2460 is_table,
2461 );
2462
2463 FlexItem {
2464 box_: self,
2465 content_cross_sizes: content_cross_sizes.clone(),
2466 padding,
2467 border,
2468 margin: config.sides_to_flex_relative(pbm.margin),
2469 pbm_auto_is_zero,
2470 flex_base_size,
2471 flex_base_size_is_definite,
2472 hypothetical_main_size: flex_base_size
2473 .clamp_between_extremums(content_min_main_size, content_max_main_size),
2474 content_min_main_size,
2475 content_max_main_size,
2476 align_self,
2477 depends_on_block_constraints: *depends_on_block_constraints,
2478 preferred_aspect_ratio,
2479 automatic_cross_size,
2480 automatic_cross_size_for_intrinsic_sizing,
2481 }
2482 }
2483
2484 fn main_content_size_info<'a>(
2485 &self,
2486 layout_context: &LayoutContext,
2487 containing_block: &IndefiniteContainingBlock,
2488 config: &FlexContainerConfig,
2489 flex_context_getter: &impl Fn() -> &'a FlexContext<'a>,
2490 ) -> FlexItemBoxInlineContentSizesInfo {
2491 let content_box_sizes_and_pbm = self
2492 .independent_formatting_context
2493 .layout_style()
2494 .content_box_sizes_and_padding_border_margin(containing_block);
2495
2496 let FlexItem {
2499 flex_base_size,
2500 content_min_main_size,
2501 content_max_main_size,
2502 pbm_auto_is_zero,
2503 preferred_aspect_ratio,
2504 automatic_cross_size_for_intrinsic_sizing,
2505 ..
2506 } = self.to_flex_item(
2507 layout_context,
2508 containing_block,
2509 &content_box_sizes_and_pbm,
2510 config,
2511 flex_context_getter,
2512 );
2513
2514 let (content_contribution_sizes, depends_on_block_constraints) = match config.flex_axis {
2517 FlexAxis::Row => {
2518 let auto_minimum = LogicalVec2 {
2519 inline: content_min_main_size,
2520 block: Au::zero(),
2521 };
2522 let InlineContentSizesResult {
2523 sizes,
2524 depends_on_block_constraints,
2525 } = self
2526 .independent_formatting_context
2527 .outer_inline_content_sizes(
2528 layout_context,
2529 containing_block,
2530 &auto_minimum,
2531 automatic_cross_size_for_intrinsic_sizing == Size::Stretch,
2532 false, );
2534 (sizes, depends_on_block_constraints)
2535 },
2536 FlexAxis::Column => {
2537 let size = self.layout_for_block_content_size(
2538 flex_context_getter(),
2539 &pbm_auto_is_zero,
2540 &content_box_sizes_and_pbm.content_box_sizes,
2541 preferred_aspect_ratio,
2542 automatic_cross_size_for_intrinsic_sizing,
2543 IntrinsicSizingMode::Contribution,
2544 );
2545 (size.into(), true)
2546 },
2547 };
2548
2549 let outer_flex_base_size = flex_base_size + pbm_auto_is_zero.main;
2550 let outer_min_main_size = content_min_main_size + pbm_auto_is_zero.main;
2551 let outer_max_main_size = content_max_main_size.map(|v| v + pbm_auto_is_zero.main);
2552 let max_flex_factors = self.desired_flex_factors_for_preferred_width(
2553 content_contribution_sizes.max_content,
2554 flex_base_size,
2555 outer_flex_base_size,
2556 );
2557
2558 let min_flex_factors = self.desired_flex_factors_for_preferred_width(
2562 content_contribution_sizes.min_content,
2563 flex_base_size,
2564 outer_flex_base_size,
2565 );
2566
2567 let mut min_content_main_size_for_multiline_container =
2574 content_contribution_sizes.min_content;
2575 let style_position = &self.style().get_position();
2576 if style_position.flex_grow.is_zero() {
2577 min_content_main_size_for_multiline_container.min_assign(outer_flex_base_size);
2578 }
2579 if style_position.flex_shrink.is_zero() {
2580 min_content_main_size_for_multiline_container.max_assign(outer_flex_base_size);
2581 }
2582 min_content_main_size_for_multiline_container =
2583 min_content_main_size_for_multiline_container
2584 .clamp_between_extremums(outer_min_main_size, outer_max_main_size);
2585
2586 FlexItemBoxInlineContentSizesInfo {
2587 outer_flex_base_size,
2588 outer_min_main_size,
2589 outer_max_main_size,
2590 min_flex_factors,
2591 max_flex_factors,
2592 min_content_main_size_for_multiline_container,
2593 depends_on_block_constraints,
2594 }
2595 }
2596
2597 fn desired_flex_factors_for_preferred_width(
2598 &self,
2599 preferred_width: Au,
2600 flex_base_size: Au,
2601 outer_flex_base_size: Au,
2602 ) -> DesiredFlexFractionAndGrowOrShrinkFactor {
2603 let difference = (preferred_width - outer_flex_base_size).to_f32_px();
2604 let (flex_grow_or_scaled_flex_shrink_factor, desired_flex_fraction) = if difference > 0.0 {
2605 let flex_grow_factor = self.style().get_position().flex_grow.0;
2609
2610 (
2611 flex_grow_factor,
2612 if flex_grow_factor >= 1.0 {
2613 difference / flex_grow_factor
2614 } else {
2615 difference * flex_grow_factor
2616 },
2617 )
2618 } else if difference < 0.0 {
2619 let flex_shrink_factor = self.style().get_position().flex_shrink.0;
2623 let scaled_flex_shrink_factor = flex_shrink_factor * flex_base_size.to_f32_px();
2624
2625 (
2626 scaled_flex_shrink_factor,
2627 if scaled_flex_shrink_factor != 0.0 {
2628 difference / scaled_flex_shrink_factor
2629 } else {
2630 f32::NEG_INFINITY
2631 },
2632 )
2633 } else {
2634 (0.0, 0.0)
2635 };
2636
2637 DesiredFlexFractionAndGrowOrShrinkFactor {
2638 desired_flex_fraction,
2639 flex_grow_or_shrink_factor: flex_grow_or_scaled_flex_shrink_factor,
2640 }
2641 }
2642
2643 fn flex_basis(
2649 &self,
2650 container_definite_main_size: Option<Au>,
2651 main_preferred_size: Size<Au>,
2652 main_padding_border_sum: Au,
2653 ) -> Size<Au> {
2654 let style_position = &self.independent_formatting_context.style().get_position();
2655 match &style_position.flex_basis {
2656 FlexBasis::Content => Size::Initial,
2659
2660 FlexBasis::Size(size) => match Size::<LengthPercentage>::from(size) {
2661 Size::Initial => main_preferred_size,
2665
2666 size => {
2676 let apply_box_sizing = |length: Au| {
2677 match style_position.box_sizing {
2678 BoxSizing::ContentBox => length,
2679 BoxSizing::BorderBox => length - main_padding_border_sum,
2682 }
2683 };
2684 size.resolve_percentages_for_preferred(container_definite_main_size)
2685 .map(apply_box_sizing)
2686 },
2687 },
2688 }
2689 }
2690
2691 #[servo_tracing::instrument(name = "FlexContainer::layout_for_block_content_size", skip_all)]
2692 fn layout_for_block_content_size(
2693 &self,
2694 flex_context: &FlexContext,
2695 pbm_auto_is_zero: &FlexRelativeVec2<Au>,
2696 content_box_sizes: &LogicalVec2<Sizes>,
2697 preferred_aspect_ratio: Option<AspectRatio>,
2698 automatic_inline_size: Size<Au>,
2699 intrinsic_sizing_mode: IntrinsicSizingMode,
2700 ) -> Au {
2701 let content_block_size = || {
2702 let mut positioning_context = PositioningContext::default();
2703
2704 let tentative_block_size = SizeConstraint::default();
2708
2709 let inline_size = {
2712 let stretch_size = flex_context
2713 .containing_block
2714 .inline_stretch_size(pbm_auto_is_zero.cross);
2715 let get_content_size = || {
2716 self.inline_content_sizes(
2717 flex_context,
2718 tentative_block_size,
2719 preferred_aspect_ratio,
2720 )
2721 };
2722 content_box_sizes.inline.resolve(
2723 LogicalAxis::Inline,
2724 automatic_inline_size,
2725 Au::zero,
2726 stretch_size,
2727 get_content_size,
2728 false,
2729 )
2730 };
2731
2732 self.independent_formatting_context
2733 .content_block_size_under_default_constraint(
2734 flex_context.layout_context,
2735 &mut positioning_context,
2736 inline_size,
2737 flex_context.containing_block,
2738 preferred_aspect_ratio,
2739 &LazySize::intrinsic(),
2740 )
2741 };
2742 match intrinsic_sizing_mode {
2743 IntrinsicSizingMode::Contribution => {
2744 let stretch_size = flex_context
2745 .containing_block
2746 .block_stretch_size(pbm_auto_is_zero.main);
2747 let inner_block_size = content_box_sizes.block.resolve(
2748 LogicalAxis::Block,
2749 Size::FitContent,
2750 Au::zero,
2751 stretch_size,
2752 || ContentSizes::from(content_block_size()),
2753 false, );
2761 inner_block_size + pbm_auto_is_zero.main
2762 },
2763 IntrinsicSizingMode::Size => content_block_size(),
2764 }
2765 }
2766
2767 fn inline_content_sizes(
2768 &self,
2769 flex_context: &FlexContext,
2770 block_size: SizeConstraint,
2771 preferred_aspect_ratio: Option<AspectRatio>,
2772 ) -> ContentSizes {
2773 let style = self.independent_formatting_context.style();
2774 let constraint_space = ConstraintSpace::new(block_size, style, preferred_aspect_ratio);
2775 self.independent_formatting_context
2776 .inline_content_sizes(flex_context.layout_context, &constraint_space)
2777 .sizes
2778 }
2779}