⎇ 83ea1eab8b724c37f4d77cce0f40e04c219a5378
src/compute/flexbox.rs
Ñawpa willay
Pi imata llamkarqan
ch'uya
Pass cross-axis known_dimension when computing flex item min size (0.3.x) (#544)
1//! Computes the [flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) layout algorithm on [`Taffy`](crate::Taffy) according to the [spec](https://www.w3.org/TR/css-flexbox-1/)
2use core::f32;
3
4use crate::compute::common::alignment::compute_alignment_offset;
5use crate::compute::{GenericAlgorithm, LayoutAlgorithm};
6use crate::geometry::{Point, Rect, Size};
7use crate::layout::{Layout, RunMode, SizeAndBaselines, SizingMode};
8use crate::math::MaybeMath;
9use crate::node::Node;
10use crate::prelude::{TaffyMaxContent, TaffyMinContent};
11use crate::resolve::{MaybeResolve, ResolveOrZero};
12use crate::style::{
13 AlignContent, AlignItems, AlignSelf, AvailableSpace, Dimension, Display, FlexWrap, JustifyContent,
14 LengthPercentageAuto, Position,
15};
16use crate::style::{FlexDirection, Style};
17use crate::sys::Vec;
18use crate::sys::{f32_max, new_vec_with_capacity};
19use crate::tree::LayoutTree;
20
21#[cfg(feature = "debug")]
22use crate::debug::NODE_LOGGER;
23
24/// The public interface to Taffy's Flexbox algorithm implementation
25pub(crate) struct FlexboxAlgorithm;
26impl LayoutAlgorithm for FlexboxAlgorithm {
27 const NAME: &'static str = "FLEXBOX";
28
29 fn perform_layout(
30 tree: &mut impl LayoutTree,
31 node: Node,
32 known_dimensions: Size<Option<f32>>,
33 parent_size: Size<Option<f32>>,
34 available_space: Size<AvailableSpace>,
35 _sizing_mode: SizingMode,
36 ) -> SizeAndBaselines {
37 compute(tree, node, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
38 }
39
40 fn measure_size(
41 tree: &mut impl LayoutTree,
42 node: Node,
43 known_dimensions: Size<Option<f32>>,
44 parent_size: Size<Option<f32>>,
45 available_space: Size<AvailableSpace>,
46 _sizing_mode: SizingMode,
47 ) -> Size<f32> {
48 compute(tree, node, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
49 }
50}
51
52/// The intermediate results of a flexbox calculation for a single item
53struct FlexItem {
54 /// The identifier for the associated [`Node`](crate::node::Node)
55 node: Node,
56
57 /// The base size of this item
58 size: Size<Option<f32>>,
59 /// The minimum allowable size of this item
60 min_size: Size<Option<f32>>,
61 /// The maximum allowable size of this item
62 max_size: Size<Option<f32>>,
63 /// The cross-alignment of this item
64 align_self: AlignSelf,
65
66 /// The flex shrink style of the item
67 flex_shrink: f32,
68 /// The flex grow style of the item
69 flex_grow: f32,
70
71 /// The minimum size of the item. This differs from min_size above because it also
72 /// takes into account content based automatic minimum sizes
73 resolved_minimum_size: Size<f32>,
74
75 /// The final offset of this item
76 inset: Rect<Option<f32>>,
77 /// The margin of this item
78 margin: Rect<f32>,
79 /// Whether each margin is an auto margin or not
80 margin_is_auto: Rect<bool>,
81 /// The padding of this item
82 padding: Rect<f32>,
83 /// The border of this item
84 border: Rect<f32>,
85
86 /// The default size of this item
87 flex_basis: f32,
88 /// The default size of this item, minus padding and border
89 inner_flex_basis: f32,
90 /// The amount by which this item has deviated from its target size
91 violation: f32,
92 /// Is the size of this item locked
93 frozen: bool,
94
95 /// Either the max- or min- content flex fraction
96 /// See https://www.w3.org/TR/css-flexbox-1/#intrinsic-main-sizes
97 content_flex_fraction: f32,
98
99 /// The proposed inner size of this item
100 hypothetical_inner_size: Size<f32>,
101 /// The proposed outer size of this item
102 hypothetical_outer_size: Size<f32>,
103 /// The size that this item wants to be
104 target_size: Size<f32>,
105 /// The size that this item wants to be, plus any padding and border
106 outer_target_size: Size<f32>,
107
108 /// The position of the bottom edge of this item
109 baseline: f32,
110
111 /// A temporary value for the main offset
112 ///
113 /// Offset is the relative position from the item's natural flow position based on
114 /// relative position values, alignment, and justification. Does not include margin/padding/border.
115 offset_main: f32,
116 /// A temporary value for the cross offset
117 ///
118 /// Offset is the relative position from the item's natural flow position based on
119 /// relative position values, alignment, and justification. Does not include margin/padding/border.
120 offset_cross: f32,
121}
122
123/// A line of [`FlexItem`] used for intermediate computation
124struct FlexLine<'a> {
125 /// The slice of items to iterate over during computation of this line
126 items: &'a mut [FlexItem],
127 /// The dimensions of the cross-axis
128 cross_size: f32,
129 /// The relative offset of the cross-axis
130 offset_cross: f32,
131}
132
133/// Values that can be cached during the flexbox algorithm
134struct AlgoConstants {
135 /// The direction of the current segment being laid out
136 dir: FlexDirection,
137 /// Is this segment a row
138 is_row: bool,
139 /// Is this segment a column
140 is_column: bool,
141 /// Is wrapping enabled (in either direction)
142 is_wrap: bool,
143 /// Is the wrap direction inverted
144 is_wrap_reverse: bool,
145
146 /// The item's min_size style
147 min_size: Size<Option<f32>>,
148 /// The item's max_size style
149 max_size: Size<Option<f32>>,
150 /// The margin of this section
151 margin: Rect<f32>,
152 /// The border of this section
153 border: Rect<f32>,
154 /// The padding of this section
155 padding_border: Rect<f32>,
156 /// The gap of this section
157 gap: Size<f32>,
158 /// The align_items property of this node
159 align_items: AlignItems,
160 /// The align_content property of this node
161 align_content: AlignContent,
162 /// The justify_content property of this node
163 justify_content: Option<JustifyContent>,
164
165 /// The border-box size of the node being laid out (if known)
166 node_outer_size: Size<Option<f32>>,
167 /// The content-box size of the node being laid out (if known)
168 node_inner_size: Size<Option<f32>>,
169
170 /// The size of the virtual container containing the flex items.
171 container_size: Size<f32>,
172 /// The size of the internal container
173 inner_container_size: Size<f32>,
174}
175
176/// Computes the layout of [`LayoutTree`] according to the flexbox algorithm
177pub fn compute(
178 tree: &mut impl LayoutTree,
179 node: Node,
180 known_dimensions: Size<Option<f32>>,
181 parent_size: Size<Option<f32>>,
182 available_space: Size<AvailableSpace>,
183 run_mode: RunMode,
184) -> SizeAndBaselines {
185 let style = tree.style(node);
186
187 // Pull these out earlier to avoid borrowing issues
188 let aspect_ratio = style.aspect_ratio;
189 let min_size = style.min_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
190 let max_size = style.max_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio);
191 let clamped_style_size =
192 style.size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size);
193
194 // If both min and max in a given axis are set and max <= min then this determines the size in that axis
195 let min_max_definite_size = min_size.zip_map(max_size, |min, max| match (min, max) {
196 (Some(min), Some(max)) if max <= min => Some(min),
197 _ => None,
198 });
199 let styled_based_known_dimensions = known_dimensions.or(min_max_definite_size).or(clamped_style_size);
200
201 // Short-circuit layout if the container's size is fully determined by the container's size and the run mode
202 // is ComputeSize (and thus the container's size is all that we're interested in)
203 if run_mode == RunMode::ComputeSize {
204 if let Size { width: Some(width), height: Some(height) } = styled_based_known_dimensions {
205 return Size { width, height }.into();
206 }
207 }
208
209 #[cfg(feature = "debug")]
210 NODE_LOGGER.log("FLEX: single-pass");
211 compute_preliminary(tree, node, styled_based_known_dimensions, parent_size, available_space, run_mode)
212}
213
214/// Compute a preliminary size for an item
215fn compute_preliminary(
216 tree: &mut impl LayoutTree,
217 node: Node,
218 known_dimensions: Size<Option<f32>>,
219 parent_size: Size<Option<f32>>,
220 available_space: Size<AvailableSpace>,
221 run_mode: RunMode,
222) -> SizeAndBaselines {
223 // Define some general constants we will need for the remainder of the algorithm.
224 let mut constants = compute_constants(tree.style(node), known_dimensions, parent_size);
225
226 // 9. Flex Layout Algorithm
227
228 // 9.1. Initial Setup
229
230 // 1. Generate anonymous flex items as described in §4 Flex Items.
231 #[cfg(feature = "debug")]
232 NODE_LOGGER.log("generate_anonymous_flex_items");
233 let mut flex_items = generate_anonymous_flex_items(tree, node, &constants);
234
235 // 9.2. Line Length Determination
236
237 // 2. Determine the available main and cross space for the flex items
238 #[cfg(feature = "debug")]
239 NODE_LOGGER.log("determine_available_space");
240 let available_space = determine_available_space(known_dimensions, available_space, &constants);
241
242 // 3. Determine the flex base size and hypothetical main size of each item.
243 #[cfg(feature = "debug")]
244 NODE_LOGGER.log("determine_flex_base_size");
245 determine_flex_base_size(tree, &constants, available_space, &mut flex_items);
246
247 #[cfg(feature = "debug")]
248 for item in flex_items.iter() {
249 NODE_LOGGER.labelled_log("item.flex_basis", item.flex_basis);
250 NODE_LOGGER.labelled_log("item.inner_flex_basis", item.inner_flex_basis);
251 NODE_LOGGER.labelled_debug_log("item.hypothetical_outer_size", item.hypothetical_outer_size);
252 NODE_LOGGER.labelled_debug_log("item.hypothetical_inner_size", item.hypothetical_inner_size);
253 NODE_LOGGER.labelled_debug_log("item.resolved_minimum_size", item.resolved_minimum_size);
254 }
255
256 // 4. Determine the main size of the flex container
257 // This has already been done as part of compute_constants. The inner size is exposed as constants.node_inner_size.
258
259 // 9.3. Main Size Determination
260
261 // 5. Collect flex items into flex lines.
262 #[cfg(feature = "debug")]
263 NODE_LOGGER.log("collect_flex_lines");
264 let mut flex_lines = collect_flex_lines(&constants, available_space, &mut flex_items);
265
266 // If container size is undefined, determine the container's main size
267 // and then re-resolve gaps based on newly determined size
268 #[cfg(feature = "debug")]
269 NODE_LOGGER.log("determine_container_main_size");
270 let original_gap = constants.gap;
271 if let Some(inner_main_size) = constants.node_inner_size.main(constants.dir) {
272 let outer_main_size = inner_main_size + constants.padding_border.main_axis_sum(constants.dir);
273 constants.inner_container_size.set_main(constants.dir, inner_main_size);
274 constants.container_size.set_main(constants.dir, outer_main_size);
275 } else {
276 // Sets constants.container_size and constants.outer_container_size
277 determine_container_main_size(tree, available_space, &mut flex_lines, &mut constants);
278 constants.node_inner_size.set_main(constants.dir, Some(constants.inner_container_size.main(constants.dir)));
279 constants.node_outer_size.set_main(constants.dir, Some(constants.container_size.main(constants.dir)));
280
281 #[cfg(feature = "debug")]
282 NODE_LOGGER.labelled_debug_log("constants.node_outer_size", constants.node_outer_size);
283 #[cfg(feature = "debug")]
284 NODE_LOGGER.labelled_debug_log("constants.node_inner_size", constants.node_inner_size);
285
286 // Re-resolve percentage gaps
287 let style = tree.style(node);
288 let inner_container_size = constants.inner_container_size.main(constants.dir);
289 let new_gap = style.gap.main(constants.dir).maybe_resolve(inner_container_size).unwrap_or(0.0);
290 constants.gap.set_main(constants.dir, new_gap);
291 }
292
293 // 6. Resolve the flexible lengths of all the flex items to find their used main size.
294 #[cfg(feature = "debug")]
295 NODE_LOGGER.log("resolve_flexible_lengths");
296 for line in &mut flex_lines {
297 resolve_flexible_lengths(line, &constants, original_gap);
298 }
299
300 // 9.4. Cross Size Determination
301
302 // 7. Determine the hypothetical cross size of each item.
303 #[cfg(feature = "debug")]
304 NODE_LOGGER.log("determine_hypothetical_cross_size");
305 for line in &mut flex_lines {
306 determine_hypothetical_cross_size(tree, line, &constants, available_space);
307 }
308
309 // Calculate child baselines. This function is internally smart and only computes child baselines
310 // if they are necessary.
311 #[cfg(feature = "debug")]
312 NODE_LOGGER.log("calculate_children_base_lines");
313 calculate_children_base_lines(tree, known_dimensions, available_space, &mut flex_lines, &constants);
314
315 // 8. Calculate the cross size of each flex line.
316 #[cfg(feature = "debug")]
317 NODE_LOGGER.log("calculate_cross_size");
318 calculate_cross_size(&mut flex_lines, known_dimensions, &constants);
319
320 // 9. Handle 'align-content: stretch'.
321 #[cfg(feature = "debug")]
322 NODE_LOGGER.log("handle_align_content_stretch");
323 handle_align_content_stretch(&mut flex_lines, known_dimensions, &constants);
324
325 // 10. Collapse visibility:collapse items. If any flex items have visibility: collapse,
326 // note the cross size of the line they’re in as the item’s strut size, and restart
327 // layout from the beginning.
328 //
329 // In this second layout round, when collecting items into lines, treat the collapsed
330 // items as having zero main size. For the rest of the algorithm following that step,
331 // ignore the collapsed items entirely (as if they were display:none) except that after
332 // calculating the cross size of the lines, if any line’s cross size is less than the
333 // largest strut size among all the collapsed items in the line, set its cross size to
334 // that strut size.
335 //
336 // Skip this step in the second layout round.
337
338 // TODO implement once (if ever) we support visibility:collapse
339
340 // 11. Determine the used cross size of each flex item.
341 #[cfg(feature = "debug")]
342 NODE_LOGGER.log("determine_used_cross_size");
343 determine_used_cross_size(tree, &mut flex_lines, &constants);
344
345 // 9.5. Main-Axis Alignment
346
347 // 12. Distribute any remaining free space.
348 #[cfg(feature = "debug")]
349 NODE_LOGGER.log("distribute_remaining_free_space");
350 distribute_remaining_free_space(&mut flex_lines, &constants);
351
352 // 9.6. Cross-Axis Alignment
353
354 // 13. Resolve cross-axis auto margins (also includes 14).
355 #[cfg(feature = "debug")]
356 NODE_LOGGER.log("resolve_cross_axis_auto_margins");
357 resolve_cross_axis_auto_margins(&mut flex_lines, &constants);
358
359 // 15. Determine the flex container’s used cross size.
360 #[cfg(feature = "debug")]
361 NODE_LOGGER.log("determine_container_cross_size");
362 let total_line_cross_size = determine_container_cross_size(&flex_lines, known_dimensions, &mut constants);
363
364 // We have the container size.
365 // If our caller does not care about performing layout we are done now.
366 if run_mode == RunMode::ComputeSize {
367 return constants.container_size.into();
368 }
369
370 // 16. Align all flex lines per align-content.
371 #[cfg(feature = "debug")]
372 NODE_LOGGER.log("align_flex_lines_per_align_content");
373 align_flex_lines_per_align_content(&mut flex_lines, &constants, total_line_cross_size);
374
375 // Do a final layout pass and gather the resulting layouts
376 #[cfg(feature = "debug")]
377 NODE_LOGGER.log("final_layout_pass");
378 final_layout_pass(tree, node, &mut flex_lines, &constants);
379
380 // Before returning we perform absolute layout on all absolutely positioned children
381 #[cfg(feature = "debug")]
382 NODE_LOGGER.log("perform_absolute_layout_on_absolute_children");
383 perform_absolute_layout_on_absolute_children(tree, node, &constants);
384
385 #[cfg(feature = "debug")]
386 NODE_LOGGER.log("hidden_layout");
387 let len = tree.child_count(node);
388 for order in 0..len {
389 let child = tree.child(node, order);
390 if tree.style(child).display == Display::None {
391 *tree.layout_mut(child) = Layout::with_order(order as u32);
392 GenericAlgorithm::perform_layout(
393 tree,
394 child,
395 Size::NONE,
396 Size::NONE,
397 Size::MAX_CONTENT,
398 SizingMode::InherentSize,
399 );
400 }
401 }
402
403 // 8.5. Flex Container Baselines: calculate the flex container's first baseline
404 // See https://www.w3.org/TR/css-flexbox-1/#flex-baselines
405 let first_vertical_baseline = if flex_lines.is_empty() {
406 None
407 } else {
408 flex_lines[0]
409 .items
410 .iter()
411 .find(|item| constants.is_column || item.align_self == AlignSelf::Baseline)
412 .or_else(|| flex_lines[0].items.iter().next())
413 .map(|child| {
414 let offset_vertical = if constants.is_row { child.offset_cross } else { child.offset_main };
415 offset_vertical + child.baseline
416 })
417 };
418
419 SizeAndBaselines { size: constants.container_size, first_baselines: Point { x: None, y: first_vertical_baseline } }
420}
421
422/// Compute constants that can be reused during the flexbox algorithm.
423#[inline]
424fn compute_constants(
425 style: &Style,
426 known_dimensions: Size<Option<f32>>,
427 parent_size: Size<Option<f32>>,
428) -> AlgoConstants {
429 let dir = style.flex_direction;
430 let is_row = dir.is_row();
431 let is_column = dir.is_column();
432 let is_wrap = matches!(style.flex_wrap, FlexWrap::Wrap | FlexWrap::WrapReverse);
433 let is_wrap_reverse = style.flex_wrap == FlexWrap::WrapReverse;
434
435 let aspect_ratio = style.aspect_ratio;
436 let margin = style.margin.resolve_or_zero(parent_size.width);
437 let padding = style.padding.resolve_or_zero(parent_size.width);
438 let border = style.border.resolve_or_zero(parent_size.width);
439 let align_items = style.align_items.unwrap_or(AlignItems::Stretch);
440 let align_content = style.align_content.unwrap_or(AlignContent::Stretch);
441 let justify_content = style.justify_content;
442
443 let padding_border = padding + border;
444
445 let node_outer_size = known_dimensions;
446 let node_inner_size = node_outer_size.maybe_sub(padding_border.sum_axes());
447 let gap = style.gap.resolve_or_zero(node_inner_size.or(Size::zero()));
448
449 let container_size = Size::zero();
450 let inner_container_size = Size::zero();
451
452 AlgoConstants {
453 dir,
454 is_row,
455 is_column,
456 is_wrap,
457 is_wrap_reverse,
458 min_size: style.min_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio),
459 max_size: style.max_size.maybe_resolve(parent_size).maybe_apply_aspect_ratio(aspect_ratio),
460 margin,
461 border,
462 gap,
463 padding_border,
464 align_items,
465 align_content,
466 justify_content,
467 node_outer_size,
468 node_inner_size,
469 container_size,
470 inner_container_size,
471 }
472}
473
474/// Generate anonymous flex items.
475///
476/// # [9.1. Initial Setup](https://www.w3.org/TR/css-flexbox-1/#box-manip)
477///
478/// - [**Generate anonymous flex items**](https://www.w3.org/TR/css-flexbox-1/#algo-anon-box) as described in [§4 Flex Items](https://www.w3.org/TR/css-flexbox-1/#flex-items).
479#[inline]
480fn generate_anonymous_flex_items(tree: &impl LayoutTree, node: Node, constants: &AlgoConstants) -> Vec<FlexItem> {
481 tree.children(node)
482 .map(|child| (child, tree.style(*child)))
483 .filter(|(_, style)| style.position != Position::Absolute)
484 .filter(|(_, style)| style.display != Display::None)
485 .map(|(child, child_style)| {
486 let aspect_ratio = child_style.aspect_ratio;
487 FlexItem {
488 node: *child,
489 size: child_style.size.maybe_resolve(constants.node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
490 min_size: child_style
491 .min_size
492 .maybe_resolve(constants.node_inner_size)
493 .maybe_apply_aspect_ratio(aspect_ratio),
494 max_size: child_style
495 .max_size
496 .maybe_resolve(constants.node_inner_size)
497 .maybe_apply_aspect_ratio(aspect_ratio),
498
499 inset: child_style.inset.zip_size(constants.node_inner_size, |p, s| p.maybe_resolve(s)),
500 margin: child_style.margin.resolve_or_zero(constants.node_inner_size.width),
501 margin_is_auto: child_style.margin.map(|m| m == LengthPercentageAuto::Auto),
502 padding: child_style.padding.resolve_or_zero(constants.node_inner_size.width),
503 border: child_style.border.resolve_or_zero(constants.node_inner_size.width),
504 align_self: child_style.align_self.unwrap_or(constants.align_items),
505 flex_grow: child_style.flex_grow,
506 flex_shrink: child_style.flex_shrink,
507 flex_basis: 0.0,
508 inner_flex_basis: 0.0,
509 violation: 0.0,
510 frozen: false,
511
512 resolved_minimum_size: Size::zero(),
513 hypothetical_inner_size: Size::zero(),
514 hypothetical_outer_size: Size::zero(),
515 target_size: Size::zero(),
516 outer_target_size: Size::zero(),
517 content_flex_fraction: 0.0,
518
519 baseline: 0.0,
520
521 offset_main: 0.0,
522 offset_cross: 0.0,
523 }
524 })
525 .collect()
526}
527
528/// Determine the available main and cross space for the flex items.
529///
530/// # [9.2. Line Length Determination](https://www.w3.org/TR/css-flexbox-1/#line-sizing)
531///
532/// - [**Determine the available main and cross space for the flex items**](https://www.w3.org/TR/css-flexbox-1/#algo-available).
533/// For each dimension, if that dimension of the flex container’s content box is a definite size, use that;
534/// if that dimension of the flex container is being sized under a min or max-content constraint, the available space in that dimension is that constraint;
535/// otherwise, subtract the flex container’s margin, border, and padding from the space available to the flex container in that dimension and use that value.
536/// **This might result in an infinite value**.
537#[inline]
538#[must_use]
539fn determine_available_space(
540 known_dimensions: Size<Option<f32>>,
541 outer_available_space: Size<AvailableSpace>,
542 constants: &AlgoConstants,
543) -> Size<AvailableSpace> {
544 // Note: min/max/preferred size styles have already been applied to known_dimensions in the `compute` function above
545 let width = match known_dimensions.width {
546 Some(node_width) => AvailableSpace::Definite(node_width - constants.padding_border.horizontal_axis_sum()),
547 None => outer_available_space
548 .width
549 .maybe_sub(constants.margin.horizontal_axis_sum())
550 .maybe_sub(constants.padding_border.horizontal_axis_sum()),
551 };
552
553 let height = match known_dimensions.height {
554 Some(node_height) => AvailableSpace::Definite(node_height - constants.padding_border.vertical_axis_sum()),
555 None => outer_available_space
556 .height
557 .maybe_sub(constants.margin.vertical_axis_sum())
558 .maybe_sub(constants.padding_border.vertical_axis_sum()),
559 };
560
561 Size { width, height }
562}
563
564/// Determine the flex base size and hypothetical main size of each item.
565///
566/// # [9.2. Line Length Determination](https://www.w3.org/TR/css-flexbox-1/#line-sizing)
567///
568/// - [**Determine the flex base size and hypothetical main size of each item:**](https://www.w3.org/TR/css-flexbox-1/#algo-main-item)
569///
570/// - A. If the item has a definite used flex basis, that’s the flex base size.
571///
572/// - B. If the flex item has ...
573///
574/// - an intrinsic aspect ratio,
575/// - a used flex basis of content, and
576/// - a definite cross size,
577///
578/// then the flex base size is calculated from its inner cross size and the flex item’s intrinsic aspect ratio.
579///
580/// - C. If the used flex basis is content or depends on its available space, and the flex container is being sized under a min-content
581/// or max-content constraint (e.g. when performing automatic table layout \[CSS21\]), size the item under that constraint.
582/// The flex base size is the item’s resulting main size.
583///
584/// - E. Otherwise, size the item into the available space using its used flex basis in place of its main size, treating a value of content as max-content.
585/// If a cross size is needed to determine the main size (e.g. when the flex item’s main size is in its block axis) and the flex item’s cross size is auto and not definite,
586/// in this calculation use fit-content as the flex item’s cross size. The flex base size is the item’s resulting main size.
587///
588/// When determining the flex base size, the item’s min and max main sizes are ignored (no clamping occurs).
589/// Furthermore, the sizing calculations that floor the content box size at zero when applying box-sizing are also ignored.
590/// (For example, an item with a specified size of zero, positive padding, and box-sizing: border-box will have an outer flex base size of zero—and hence a negative inner flex base size.)
591#[inline]
592fn determine_flex_base_size(
593 tree: &mut impl LayoutTree,
594 constants: &AlgoConstants,
595 available_space: Size<AvailableSpace>,
596 flex_items: &mut [FlexItem],
597) {
598 let dir = constants.dir;
599
600 for child in flex_items.iter_mut() {
601 let child_style = tree.style(child.node);
602
603 // Parent size for child sizing
604 let cross_axis_parent_size = constants.node_inner_size.cross(dir);
605 let child_parent_size = Size::NONE.with_cross(dir, cross_axis_parent_size);
606
607 // Available space for child sizing
608 let cross_axis_margin_sum = constants.margin.cross_axis_sum(dir);
609 let child_min_cross = child.min_size.cross(dir).maybe_add(cross_axis_margin_sum);
610 let child_max_cross = child.max_size.cross(dir).maybe_add(cross_axis_margin_sum);
611 let cross_axis_available_space: AvailableSpace =
612 cross_axis_parent_size.maybe_clamp(child_min_cross, child_max_cross).into();
613
614 // Known dimension for child sizing
615 let child_known_dimensions = {
616 let mut ckd = child.size.with_main(dir, None);
617 if child.align_self == AlignSelf::Stretch && ckd.cross(dir).is_none() {
618 ckd.set_cross(
619 dir,
620 cross_axis_available_space.into_option().maybe_sub(child.margin.cross_axis_sum(dir)),
621 );
622 }
623 ckd
624 };
625
626 child.flex_basis = 'flex_basis: {
627 // A. If the item has a definite used flex basis, that’s the flex base size.
628
629 // B. If the flex item has an intrinsic aspect ratio,
630 // a used flex basis of content, and a definite cross size,
631 // then the flex base size is calculated from its inner
632 // cross size and the flex item’s intrinsic aspect ratio.
633
634 // Note: `child.size` has already been resolved against aspect_ratio in generate_anonymous_flex_items
635 // So B will just work here by using main_size without special handling for aspect_ratio
636
637 let flex_basis = child_style.flex_basis.maybe_resolve(constants.node_inner_size.main(dir));
638 let main_size = child.size.main(dir);
639 if let Some(flex_basis) = flex_basis.or(main_size) {
640 break 'flex_basis flex_basis;
641 };
642
643 // C. If the used flex basis is content or depends on its available space,
644 // and the flex container is being sized under a min-content or max-content
645 // constraint (e.g. when performing automatic table layout [CSS21]),
646 // size the item under that constraint. The flex base size is the item’s
647 // resulting main size.
648
649 // This is covered by the implementation of E below, which passes the available_space constraint
650 // through to the child size computation. It may need a separate implementation if/when D is implemented.
651
652 // D. Otherwise, if the used flex basis is content or depends on its
653 // available space, the available main size is infinite, and the flex item’s
654 // inline axis is parallel to the main axis, lay the item out using the rules
655 // for a box in an orthogonal flow [CSS3-WRITING-MODES]. The flex base size
656 // is the item’s max-content main size.
657
658 // TODO if/when vertical writing modes are supported
659
660 // E. Otherwise, size the item into the available space using its used flex basis
661 // in place of its main size, treating a value of content as max-content.
662 // If a cross size is needed to determine the main size (e.g. when the
663 // flex item’s main size is in its block axis) and the flex item’s cross size
664 // is auto and not definite, in this calculation use fit-content as the
665 // flex item’s cross size. The flex base size is the item’s resulting main size.
666
667 let child_available_space = available_space.with_cross(dir, cross_axis_available_space);
668
669 break 'flex_basis GenericAlgorithm::measure_size(
670 tree,
671 child.node,
672 child_known_dimensions,
673 child_parent_size,
674 child_available_space,
675 SizingMode::ContentSize,
676 )
677 .main(dir);
678 };
679
680 // Floor flex-basis by the padding_border_sum (floors inner_flex_basis at zero)
681 // This seems to be in violation of the spec which explicitly states that the content box should not be floored at zero
682 // (like it usually is) when calculating the flex-basis. But including this matches both Chrome and Firefox's behaviour.
683 //
684 // TODO: resolve spec violation
685 // Spec: https://www.w3.org/TR/css-flexbox-1/#intrinsic-item-contributions
686 // Spec: https://www.w3.org/TR/css-flexbox-1/#change-2016-max-contribution
687 let padding_border_sum = child.padding.main_axis_sum(constants.dir) + child.border.main_axis_sum(constants.dir);
688 child.flex_basis = child.flex_basis.max(padding_border_sum);
689
690 // The hypothetical main size is the item’s flex base size clamped according to its
691 // used min and max main sizes (and flooring the content box size at zero).
692
693 child.inner_flex_basis =
694 child.flex_basis - child.padding.main_axis_sum(constants.dir) - child.border.main_axis_sum(constants.dir);
695
696 let padding_border_axes_sums = (child.padding + child.border).sum_axes().map(Some);
697 let hypothetical_inner_min_main =
698 child.min_size.main(constants.dir).maybe_max(padding_border_axes_sums.main(constants.dir));
699 let hypothetical_inner_size =
700 child.flex_basis.maybe_clamp(hypothetical_inner_min_main, child.max_size.main(constants.dir));
701 let hypothetical_outer_size = hypothetical_inner_size + child.margin.main_axis_sum(constants.dir);
702
703 child.hypothetical_inner_size.set_main(constants.dir, hypothetical_inner_size);
704 child.hypothetical_outer_size.set_main(constants.dir, hypothetical_outer_size);
705
706 // Note that it is important that the `parent_size` parameter in the main axis is not set for this
707 // function call as it used for resolving percentages, and percentage size in an axis should not contribute
708 // to a min-content contribution in that same axis. However the `parent_size` and `available_space` *should*
709 // be set to their usual values in the cross axis so that wrapping content can wrap correctly.
710 //
711 // See https://drafts.csswg.org/css-sizing-3/#min-percentage-contribution
712 let min_content_size = {
713 let child_available_space = Size::MIN_CONTENT.with_cross(dir, cross_axis_available_space);
714
715 GenericAlgorithm::measure_size(
716 tree,
717 child.node,
718 child_known_dimensions,
719 child_parent_size,
720 child_available_space,
721 SizingMode::ContentSize,
722 )
723 };
724
725 // 4.5. Automatic Minimum Size of Flex Items
726 // https://www.w3.org/TR/css-flexbox-1/#min-size-auto
727 let clamped_min_content_size = min_content_size.maybe_min(child.size).maybe_min(child.max_size);
728 child.resolved_minimum_size =
729 child.min_size.unwrap_or(clamped_min_content_size).maybe_max(padding_border_axes_sums);
730 }
731}
732
733/// Collect flex items into flex lines.
734///
735/// # [9.3. Main Size Determination](https://www.w3.org/TR/css-flexbox-1/#main-sizing)
736///
737/// - [**Collect flex items into flex lines**](https://www.w3.org/TR/css-flexbox-1/#algo-line-break):
738///
739/// - If the flex container is single-line, collect all the flex items into a single flex line.
740///
741/// - Otherwise, starting from the first uncollected item, collect consecutive items one by one until the first time that the next collected item would not fit into the flex container’s inner main size
742/// (or until a forced break is encountered, see [§10 Fragmenting Flex Layout](https://www.w3.org/TR/css-flexbox-1/#pagination)).
743/// If the very first uncollected item wouldn't fit, collect just it into the line.
744///
745/// For this step, the size of a flex item is its outer hypothetical main size. (**Note: This can be negative**.)
746///
747/// Repeat until all flex items have been collected into flex lines.
748///
749/// **Note that the "collect as many" line will collect zero-sized flex items onto the end of the previous line even if the last non-zero item exactly "filled up" the line**.
750#[inline]
751fn collect_flex_lines<'a>(
752 constants: &AlgoConstants,
753 available_space: Size<AvailableSpace>,
754 flex_items: &'a mut Vec<FlexItem>,
755) -> Vec<FlexLine<'a>> {
756 if !constants.is_wrap {
757 let mut lines = new_vec_with_capacity(1);
758 lines.push(FlexLine { items: flex_items.as_mut_slice(), cross_size: 0.0, offset_cross: 0.0 });
759 lines
760 } else {
761 match available_space.main(constants.dir) {
762 // If we're sizing under a max-content constraint then the flex items will never wrap
763 // (at least for now - future extensions to the CSS spec may add provisions for forced wrap points)
764 AvailableSpace::MaxContent => {
765 let mut lines = new_vec_with_capacity(1);
766 lines.push(FlexLine { items: flex_items.as_mut_slice(), cross_size: 0.0, offset_cross: 0.0 });
767 lines
768 }
769 // If flex-wrap is Wrap and we're sizing under a min-content constraint, then we take every possible wrapping opportunity
770 // and place each item in it's own line
771 AvailableSpace::MinContent => {
772 let mut lines = new_vec_with_capacity(flex_items.len());
773 let mut items = &mut flex_items[..];
774 while !items.is_empty() {
775 let (line_items, rest) = items.split_at_mut(1);
776 lines.push(FlexLine { items: line_items, cross_size: 0.0, offset_cross: 0.0 });
777 items = rest;
778 }
779 lines
780 }
781 AvailableSpace::Definite(main_axis_available_space) => {
782 let mut lines = new_vec_with_capacity(1);
783 let mut flex_items = &mut flex_items[..];
784 let main_axis_gap = constants.gap.main(constants.dir);
785
786 while !flex_items.is_empty() {
787 // Find index of the first item in the next line
788 // (or the last item if all remaining items are in the current line)
789 let mut line_length = 0.0;
790 let index = flex_items
791 .iter()
792 .enumerate()
793 .find(|&(idx, child)| {
794 // Gaps only occur between items (not before the first one or after the last one)
795 // So first item in the line does not contribute a gap to the line length
796 let gap_contribution = if idx == 0 { 0.0 } else { main_axis_gap };
797 line_length += child.hypothetical_outer_size.main(constants.dir) + gap_contribution;
798 line_length > main_axis_available_space && idx != 0
799 })
800 .map(|(idx, _)| idx)
801 .unwrap_or(flex_items.len());
802
803 let (items, rest) = flex_items.split_at_mut(index);
804 lines.push(FlexLine { items, cross_size: 0.0, offset_cross: 0.0 });
805 flex_items = rest;
806 }
807 lines
808 }
809 }
810 }
811}
812
813/// Determine the container's main size (if not already known)
814fn determine_container_main_size(
815 tree: &mut impl LayoutTree,
816 available_space: Size<AvailableSpace>,
817 lines: &mut Vec<FlexLine<'_>>,
818 constants: &mut AlgoConstants,
819) {
820 let dir = constants.dir;
821 let main_padding_border = constants.padding_border.main_axis_sum(constants.dir);
822
823 let outer_main_size: f32 = constants.node_outer_size.main(constants.dir).unwrap_or_else(|| {
824 match available_space.main(dir) {
825 AvailableSpace::Definite(main_axis_available_space) => {
826 let longest_line_length: f32 = lines
827 .iter()
828 .map(|line| {
829 let line_main_axis_gap = sum_axis_gaps(constants.gap.main(constants.dir), line.items.len());
830 let total_target_size = line
831 .items
832 .iter()
833 .map(|child| {
834 let padding_border_sum = (child.padding + child.border).main_axis_sum(constants.dir);
835 (child.flex_basis + child.margin.main_axis_sum(constants.dir)).max(padding_border_sum)
836 })
837 .sum::<f32>();
838 total_target_size + line_main_axis_gap
839 })
840 .max_by(|a, b| a.total_cmp(b))
841 .unwrap_or(0.0);
842 let size = longest_line_length + main_padding_border;
843 if lines.len() > 1 {
844 f32_max(size, main_axis_available_space)
845 } else {
846 size
847 }
848 }
849 AvailableSpace::MinContent if constants.is_wrap => {
850 let longest_line_length: f32 = lines
851 .iter()
852 .map(|line| {
853 let line_main_axis_gap = sum_axis_gaps(constants.gap.main(constants.dir), line.items.len());
854 let total_target_size = line
855 .items
856 .iter()
857 .map(|child| {
858 let padding_border_sum = (child.padding + child.border).main_axis_sum(constants.dir);
859 (child.flex_basis + child.margin.main_axis_sum(constants.dir)).max(padding_border_sum)
860 })
861 .sum::<f32>();
862 total_target_size + line_main_axis_gap
863 })
864 .max_by(|a, b| a.total_cmp(b))
865 .unwrap_or(0.0);
866 longest_line_length + main_padding_border
867 }
868 AvailableSpace::MinContent | AvailableSpace::MaxContent => {
869 // Define a base main_size variable. This is mutated once for iteration over the outer
870 // loop over the flex lines as:
871 // "The flex container’s max-content size is the largest sum of the afore-calculated sizes of all items within a single line."
872 let mut main_size = 0.0;
873
874 for line in lines.iter_mut() {
875 for item in line.items.iter_mut() {
876 let style_min = item.min_size.main(constants.dir);
877 let style_preferred = item.size.main(constants.dir);
878 let style_max = item.max_size.main(constants.dir);
879
880 // The spec seems a bit unclear on this point (my initial reading was that the `.maybe_max(style_preferred)` should
881 // not be included here), however this matches both Chrome and Firefox as of 9th March 2023.
882 //
883 // Spec: https://www.w3.org/TR/css-flexbox-1/#intrinsic-item-contributions
884 // Spec modifcation: https://www.w3.org/TR/css-flexbox-1/#change-2016-max-contribution
885 // Issue: https://github.com/w3c/csswg-drafts/issues/1435
886 // Gentest: padding_border_overrides_size_flex_basis_0.html
887 let clamping_basis = Some(item.flex_basis).maybe_max(style_preferred);
888 let flex_basis_min = clamping_basis.filter(|_| item.flex_shrink == 0.0);
889 let flex_basis_max = clamping_basis.filter(|_| item.flex_grow == 0.0);
890
891 let resolved_min = item.resolved_minimum_size.main(constants.dir);
892 let min_main_size = style_min
893 .maybe_max(flex_basis_min)
894 .or(flex_basis_min)
895 .unwrap_or(resolved_min)
896 .max(resolved_min);
897 let max_main_size =
898 style_max.maybe_min(flex_basis_max).or(flex_basis_max).unwrap_or(f32::INFINITY);
899
900 let content_contribution = match (min_main_size, style_preferred, max_main_size) {
901 // If the clamping values are such that max <= min, then we can avoid the expensive step of computing the content size
902 // as we know that the clamping values will override it anyway
903 (min, Some(pref), max) if max <= min || max <= pref => {
904 pref.min(max).max(min) + item.margin.main_axis_sum(constants.dir)
905 }
906 (min, _, max) if max <= min => min + item.margin.main_axis_sum(constants.dir),
907 // Else compute the min- or -max content size and apply the full formula for computing the
908 // min- or max- content contributuon
909 _ => {
910 // Parent size for child sizing
911 let cross_axis_parent_size = constants.node_inner_size.cross(dir);
912
913 // Available space for child sizing
914 let cross_axis_margin_sum = constants.margin.cross_axis_sum(dir);
915 let child_min_cross = item.min_size.cross(dir).maybe_add(cross_axis_margin_sum);
916 let child_max_cross = item.max_size.cross(dir).maybe_add(cross_axis_margin_sum);
917 let cross_axis_available_space: AvailableSpace = available_space
918 .cross(dir)
919 .map_definite_value(|val| cross_axis_parent_size.unwrap_or(val))
920 .maybe_clamp(child_min_cross, child_max_cross);
921
922 let child_available_space = available_space.with_cross(dir, cross_axis_available_space);
923
924 // Either the min- or max- content size depending on which constraint we are sizing under.
925 // TODO: Optimise by using already computed values where available
926 let content_main_size = GenericAlgorithm::measure_size(
927 tree,
928 item.node,
929 Size::NONE,
930 constants.node_inner_size,
931 child_available_space,
932 SizingMode::InherentSize,
933 )
934 .main(constants.dir)
935 + item.margin.main_axis_sum(constants.dir);
936
937 // This is somewhat bizarre in that it's asymetrical depending whether the flex container is a column or a row.
938 //
939 // I *think* this might relate to https://drafts.csswg.org/css-flexbox-1/#algo-main-container:
940 //
941 // "The automatic block size of a block-level flex container is its max-content size."
942 //
943 // Which could suggest that flex-basis defining a vertical size does not shrink because it is in the block axis, and the automatic size
944 // in the block axis is a MAX content size. Whereas a flex-basis defining a horizontal size does shrink because the automatic size in
945 // inline axis is MIN content size (although I don't have a reference for that).
946 //
947 // Ultimately, this was not found by reading the spec, but by trial and error fixing tests to align with Webkit/Firefox output.
948 // (see the `flex_basis_unconstraint_row` and `flex_basis_uncontraint_column` generated tests which demonstrate this)
949 if constants.is_row {
950 content_main_size.maybe_clamp(style_min, style_max).max(main_padding_border)
951 } else {
952 content_main_size
953 .max(item.flex_basis)
954 .maybe_clamp(style_min, style_max)
955 .max(main_padding_border)
956 }
957 }
958 };
959 item.content_flex_fraction = {
960 let diff = content_contribution - item.flex_basis;
961 if diff > 0.0 {
962 diff / f32_max(1.0, item.flex_grow)
963 } else if diff < 0.0 {
964 let scaled_shrink_factor = f32_max(1.0, item.flex_shrink * item.inner_flex_basis);
965 diff / scaled_shrink_factor
966 } else {
967 // We are assuming that diff is 0.0 here and that we haven't accidentally introduced a NaN
968 0.0
969 }
970 };
971 }
972
973 // TODO Spec says to scale everything by the line's max flex fraction. But neither Chrome nor firefox implement this
974 // so we don't either. But if we did want to, we'd need this computation here (and to use it below):
975 //
976 // Within each line, find the largest max-content flex fraction among all the flex items.
977 // let line_flex_fraction = line
978 // .items
979 // .iter()
980 // .map(|item| item.content_flex_fraction)
981 // .max_by(|a, b| a.total_cmp(b))
982 // .unwrap_or(0.0); // Unwrap case never gets hit because there is always at least one item a line
983
984 // Add each item’s flex base size to the product of:
985 // - its flex grow factor (or scaled flex shrink factor,if the chosen max-content flex fraction was negative)
986 // - the chosen max-content flex fraction
987 // then clamp that result by the max main size floored by the min main size.
988 //
989 // The flex container’s max-content size is the largest sum of the afore-calculated sizes of all items within a single line.
990 let item_main_size_sum = line
991 .items
992 .iter_mut()
993 .map(|item| {
994 let flex_fraction = item.content_flex_fraction;
995 // let flex_fraction = line_flex_fraction;
996
997 let flex_contribution = if item.content_flex_fraction > 0.0 {
998 f32_max(1.0, item.flex_grow) * flex_fraction
999 } else if item.content_flex_fraction < 0.0 {
1000 let scaled_shrink_factor = f32_max(1.0, item.flex_shrink) * item.inner_flex_basis;
1001 scaled_shrink_factor * flex_fraction
1002 } else {
1003 0.0
1004 };
1005 let size = item.flex_basis + flex_contribution;
1006 item.outer_target_size.set_main(constants.dir, size);
1007 item.target_size.set_main(constants.dir, size);
1008 size
1009 })
1010 .sum::<f32>();
1011
1012 let gap_sum = sum_axis_gaps(constants.gap.main(constants.dir), line.items.len());
1013 main_size = f32_max(main_size, item_main_size_sum + gap_sum)
1014 }
1015
1016 main_size + main_padding_border
1017 }
1018 }
1019 });
1020
1021 let outer_main_size = outer_main_size
1022 .maybe_clamp(constants.min_size.main(constants.dir), constants.max_size.main(constants.dir))
1023 .max(main_padding_border);
1024
1025 // let outer_main_size = inner_main_size + constants.padding_border.main_axis_sum(constants.dir);
1026 let inner_main_size = outer_main_size - constants.padding_border.main_axis_sum(constants.dir);
1027 constants.container_size.set_main(constants.dir, outer_main_size);
1028 constants.inner_container_size.set_main(constants.dir, inner_main_size);
1029 constants.node_inner_size.set_main(constants.dir, Some(inner_main_size));
1030}
1031
1032/// Resolve the flexible lengths of the items within a flex line.
1033/// Sets the `main` component of each item's `target_size` and `outer_target_size`
1034///
1035/// # [9.7. Resolving Flexible Lengths](https://www.w3.org/TR/css-flexbox-1/#resolve-flexible-lengths)
1036#[inline]
1037fn resolve_flexible_lengths(line: &mut FlexLine, constants: &AlgoConstants, original_gap: Size<f32>) {
1038 let total_original_main_axis_gap = sum_axis_gaps(original_gap.main(constants.dir), line.items.len());
1039 let total_main_axis_gap = sum_axis_gaps(constants.gap.main(constants.dir), line.items.len());
1040
1041 // 1. Determine the used flex factor. Sum the outer hypothetical main sizes of all
1042 // items on the line. If the sum is less than the flex container’s inner main size,
1043 // use the flex grow factor for the rest of this algorithm; otherwise, use the
1044 // flex shrink factor.
1045
1046 let total_hypothetical_outer_main_size =
1047 line.items.iter().map(|child| child.hypothetical_outer_size.main(constants.dir)).sum::<f32>();
1048 let used_flex_factor: f32 = total_original_main_axis_gap + total_hypothetical_outer_main_size;
1049 let growing = used_flex_factor < constants.node_inner_size.main(constants.dir).unwrap_or(0.0);
1050 let shrinking = !growing;
1051
1052 // 2. Size inflexible items. Freeze, setting its target main size to its hypothetical main size
1053 // - Any item that has a flex factor of zero
1054 // - If using the flex grow factor: any item that has a flex base size
1055 // greater than its hypothetical main size
1056 // - If using the flex shrink factor: any item that has a flex base size
1057 // smaller than its hypothetical main size
1058
1059 for child in line.items.iter_mut() {
1060 let inner_target_size = child.hypothetical_inner_size.main(constants.dir);
1061 child.target_size.set_main(constants.dir, inner_target_size);
1062
1063 if (child.flex_grow == 0.0 && child.flex_shrink == 0.0)
1064 || (growing && child.flex_basis > child.hypothetical_inner_size.main(constants.dir))
1065 || (shrinking && child.flex_basis < child.hypothetical_inner_size.main(constants.dir))
1066 {
1067 child.frozen = true;
1068 let outer_target_size = inner_target_size + child.margin.main_axis_sum(constants.dir);
1069 child.outer_target_size.set_main(constants.dir, outer_target_size);
1070 }
1071 }
1072
1073 // 3. Calculate initial free space. Sum the outer sizes of all items on the line,
1074 // and subtract this from the flex container’s inner main size. For frozen items,
1075 // use their outer target main size; for other items, use their outer flex base size.
1076
1077 let used_space: f32 = total_main_axis_gap
1078 + line
1079 .items
1080 .iter()
1081 .map(|child| {
1082 child.margin.main_axis_sum(constants.dir)
1083 + if child.frozen { child.outer_target_size.main(constants.dir) } else { child.flex_basis }
1084 })
1085 .sum::<f32>();
1086
1087 let initial_free_space = constants.node_inner_size.main(constants.dir).maybe_sub(used_space).unwrap_or(0.0);
1088
1089 // 4. Loop
1090
1091 loop {
1092 // a. Check for flexible items. If all the flex items on the line are frozen,
1093 // free space has been distributed; exit this loop.
1094
1095 if line.items.iter().all(|child| child.frozen) {
1096 break;
1097 }
1098
1099 // b. Calculate the remaining free space as for initial free space, above.
1100 // If the sum of the unfrozen flex items’ flex factors is less than one,
1101 // multiply the initial free space by this sum. If the magnitude of this
1102 // value is less than the magnitude of the remaining free space, use this
1103 // as the remaining free space.
1104
1105 let used_space: f32 = total_main_axis_gap
1106 + line
1107 .items
1108 .iter()
1109 .map(|child| {
1110 child.margin.main_axis_sum(constants.dir)
1111 + if child.frozen { child.outer_target_size.main(constants.dir) } else { child.flex_basis }
1112 })
1113 .sum::<f32>();
1114
1115 let mut unfrozen: Vec<&mut FlexItem> = line.items.iter_mut().filter(|child| !child.frozen).collect();
1116
1117 let (sum_flex_grow, sum_flex_shrink): (f32, f32) =
1118 unfrozen.iter().fold((0.0, 0.0), |(flex_grow, flex_shrink), item| {
1119 (flex_grow + item.flex_grow, flex_shrink + item.flex_shrink)
1120 });
1121
1122 let free_space = if growing && sum_flex_grow < 1.0 {
1123 (initial_free_space * sum_flex_grow - total_main_axis_gap)
1124 .maybe_min(constants.node_inner_size.main(constants.dir).maybe_sub(used_space))
1125 } else if shrinking && sum_flex_shrink < 1.0 {
1126 (initial_free_space * sum_flex_shrink - total_main_axis_gap)
1127 .maybe_max(constants.node_inner_size.main(constants.dir).maybe_sub(used_space))
1128 } else {
1129 (constants.node_inner_size.main(constants.dir).maybe_sub(used_space))
1130 .unwrap_or(used_flex_factor - used_space)
1131 };
1132
1133 // c. Distribute free space proportional to the flex factors.
1134 // - If the remaining free space is zero
1135 // Do Nothing
1136 // - If using the flex grow factor
1137 // Find the ratio of the item’s flex grow factor to the sum of the
1138 // flex grow factors of all unfrozen items on the line. Set the item’s
1139 // target main size to its flex base size plus a fraction of the remaining
1140 // free space proportional to the ratio.
1141 // - If using the flex shrink factor
1142 // For every unfrozen item on the line, multiply its flex shrink factor by
1143 // its inner flex base size, and note this as its scaled flex shrink factor.
1144 // Find the ratio of the item’s scaled flex shrink factor to the sum of the
1145 // scaled flex shrink factors of all unfrozen items on the line. Set the item’s
1146 // target main size to its flex base size minus a fraction of the absolute value
1147 // of the remaining free space proportional to the ratio. Note this may result
1148 // in a negative inner main size; it will be corrected in the next step.
1149 // - Otherwise
1150 // Do Nothing
1151
1152 if free_space.is_normal() {
1153 if growing && sum_flex_grow > 0.0 {
1154 for child in &mut unfrozen {
1155 child
1156 .target_size
1157 .set_main(constants.dir, child.flex_basis + free_space * (child.flex_grow / sum_flex_grow));
1158 }
1159 } else if shrinking && sum_flex_shrink > 0.0 {
1160 let sum_scaled_shrink_factor: f32 =
1161 unfrozen.iter().map(|child| child.inner_flex_basis * child.flex_shrink).sum();
1162
1163 if sum_scaled_shrink_factor > 0.0 {
1164 for child in &mut unfrozen {
1165 let scaled_shrink_factor = child.inner_flex_basis * child.flex_shrink;
1166 child.target_size.set_main(
1167 constants.dir,
1168 child.flex_basis + free_space * (scaled_shrink_factor / sum_scaled_shrink_factor),
1169 )
1170 }
1171 }
1172 }
1173 }
1174
1175 // d. Fix min/max violations. Clamp each non-frozen item’s target main size by its
1176 // used min and max main sizes and floor its content-box size at zero. If the
1177 // item’s target main size was made smaller by this, it’s a max violation.
1178 // If the item’s target main size was made larger by this, it’s a min violation.
1179
1180 let total_violation = unfrozen.iter_mut().fold(0.0, |acc, child| -> f32 {
1181 let resolved_min_main: Option<f32> = child.resolved_minimum_size.main(constants.dir).into();
1182 let max_main = child.max_size.main(constants.dir);
1183 let clamped = child.target_size.main(constants.dir).maybe_clamp(resolved_min_main, max_main).max(0.0);
1184 child.violation = clamped - child.target_size.main(constants.dir);
1185 child.target_size.set_main(constants.dir, clamped);
1186 child.outer_target_size.set_main(
1187 constants.dir,
1188 child.target_size.main(constants.dir) + child.margin.main_axis_sum(constants.dir),
1189 );
1190
1191 acc + child.violation
1192 });
1193
1194 // e. Freeze over-flexed items. The total violation is the sum of the adjustments
1195 // from the previous step ∑(clamped size - unclamped size). If the total violation is:
1196 // - Zero
1197 // Freeze all items.
1198 // - Positive
1199 // Freeze all the items with min violations.
1200 // - Negative
1201 // Freeze all the items with max violations.
1202
1203 for child in &mut unfrozen {
1204 match total_violation {
1205 v if v > 0.0 => child.frozen = child.violation > 0.0,
1206 v if v < 0.0 => child.frozen = child.violation < 0.0,
1207 _ => child.frozen = true,
1208 }
1209 }
1210
1211 // f. Return to the start of this loop.
1212 }
1213}
1214
1215/// Determine the hypothetical cross size of each item.
1216///
1217/// # [9.4. Cross Size Determination](https://www.w3.org/TR/css-flexbox-1/#cross-sizing)
1218///
1219/// - [**Determine the hypothetical cross size of each item**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-item)
1220/// by performing layout with the used main size and the available space, treating auto as fit-content.
1221#[inline]
1222fn determine_hypothetical_cross_size(
1223 tree: &mut impl LayoutTree,
1224 line: &mut FlexLine,
1225 constants: &AlgoConstants,
1226 available_space: Size<AvailableSpace>,
1227) {
1228 for child in line.items.iter_mut() {
1229 let padding_border_sum = (child.padding + child.border).cross_axis_sum(constants.dir);
1230
1231 let child_known_main = constants.container_size.main(constants.dir).into();
1232
1233 let child_cross = child
1234 .size
1235 .cross(constants.dir)
1236 .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir))
1237 .maybe_max(padding_border_sum);
1238
1239 let child_available_cross = available_space
1240 .cross(constants.dir)
1241 .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir))
1242 .maybe_max(padding_border_sum);
1243
1244 let child_inner_cross = child_cross.unwrap_or_else(|| {
1245 GenericAlgorithm::measure_size(
1246 tree,
1247 child.node,
1248 Size {
1249 width: if constants.is_row { child.target_size.width.into() } else { child_cross },
1250 height: if constants.is_row { child_cross } else { child.target_size.height.into() },
1251 },
1252 constants.node_inner_size,
1253 Size {
1254 width: if constants.is_row { child_known_main } else { child_available_cross },
1255 height: if constants.is_row { child_available_cross } else { child_known_main },
1256 },
1257 SizingMode::ContentSize,
1258 )
1259 .cross(constants.dir)
1260 .maybe_clamp(child.min_size.cross(constants.dir), child.max_size.cross(constants.dir))
1261 .max(padding_border_sum)
1262 });
1263 let child_outer_cross = child_inner_cross + child.margin.cross_axis_sum(constants.dir);
1264
1265 child.hypothetical_inner_size.set_cross(constants.dir, child_inner_cross);
1266 child.hypothetical_outer_size.set_cross(constants.dir, child_outer_cross);
1267 }
1268}
1269
1270/// Calculate the base lines of the children.
1271#[inline]
1272fn calculate_children_base_lines(
1273 tree: &mut impl LayoutTree,
1274 node_size: Size<Option<f32>>,
1275 available_space: Size<AvailableSpace>,
1276 flex_lines: &mut [FlexLine],
1277 constants: &AlgoConstants,
1278) {
1279 // Only compute baselines for flex rows because we only support baseline alignment in the cross axis
1280 // where that axis is also the inline axis
1281 // TODO: this may need revisiting if/when we support vertical writing modes
1282 if !constants.is_row {
1283 return;
1284 }
1285
1286 for line in flex_lines {
1287 // If a flex line has one or zero items participating in baseline alignment then baseline alignment is a no-op so we skip
1288 let line_baseline_child_count =
1289 line.items.iter().filter(|child| child.align_self == AlignSelf::Baseline).count();
1290 if line_baseline_child_count <= 1 {
1291 continue;
1292 }
1293
1294 for child in line.items.iter_mut() {
1295 // Only calculate baselines for children participating in baseline alignment
1296 if child.align_self != AlignSelf::Baseline {
1297 continue;
1298 }
1299
1300 let measured_size_and_baselines = GenericAlgorithm::perform_layout(
1301 tree,
1302 child.node,
1303 Size {
1304 width: if constants.is_row {
1305 child.target_size.width.into()
1306 } else {
1307 child.hypothetical_inner_size.width.into()
1308 },
1309 height: if constants.is_row {
1310 child.hypothetical_inner_size.height.into()
1311 } else {
1312 child.target_size.height.into()
1313 },
1314 },
1315 constants.node_inner_size,
1316 Size {
1317 width: if constants.is_row {
1318 constants.container_size.width.into()
1319 } else {
1320 available_space.width.maybe_set(node_size.width)
1321 },
1322 height: if constants.is_row {
1323 available_space.height.maybe_set(node_size.height)
1324 } else {
1325 constants.container_size.height.into()
1326 },
1327 },
1328 SizingMode::ContentSize,
1329 );
1330
1331 let baseline = measured_size_and_baselines.first_baselines.y;
1332 let height = measured_size_and_baselines.size.height;
1333
1334 child.baseline = baseline.unwrap_or(height) + child.margin.top;
1335 }
1336 }
1337}
1338
1339/// Calculate the cross size of each flex line.
1340///
1341/// # [9.4. Cross Size Determination](https://www.w3.org/TR/css-flexbox-1/#cross-sizing)
1342///
1343/// - [**Calculate the cross size of each flex line**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-line).
1344///
1345/// If the flex container is single-line and has a definite cross size, the cross size of the flex line is the flex container’s inner cross size.
1346///
1347/// Otherwise, for each flex line:
1348///
1349/// 1. Collect all the flex items whose inline-axis is parallel to the main-axis, whose align-self is baseline, and whose cross-axis margins are both non-auto.
1350/// Find the largest of the distances between each item’s baseline and its hypothetical outer cross-start edge,
1351/// and the largest of the distances between each item’s baseline and its hypothetical outer cross-end edge, and sum these two values.
1352///
1353/// 2. Among all the items not collected by the previous step, find the largest outer hypothetical cross size.
1354///
1355/// 3. The used cross-size of the flex line is the largest of the numbers found in the previous two steps and zero.
1356///
1357/// If the flex container is single-line, then clamp the line’s cross-size to be within the container’s computed min and max cross sizes.
1358/// **Note that if CSS 2.1’s definition of min/max-width/height applied more generally, this behavior would fall out automatically**.
1359#[inline]
1360fn calculate_cross_size(flex_lines: &mut [FlexLine], node_size: Size<Option<f32>>, constants: &AlgoConstants) {
1361 // Note: AlignContent::SpaceEvenly and AlignContent::SpaceAround behave like AlignContent::Stretch when there is only
1362 // a single flex line in the container. See: https://www.w3.org/TR/css-flexbox-1/#align-content-property
1363 // Also: align_content is ignored entirely (and thus behaves like Stretch) when `flex_wrap` is set to `nowrap`.
1364 if flex_lines.len() == 1
1365 && node_size.cross(constants.dir).is_some()
1366 && (!constants.is_wrap
1367 || matches!(
1368 constants.align_content,
1369 AlignContent::Stretch | AlignContent::SpaceEvenly | AlignContent::SpaceAround
1370 ))
1371 {
1372 let cross_axis_padding_border = constants.padding_border.cross_axis_sum(constants.dir);
1373 let cross_min_size = constants.min_size.cross(constants.dir);
1374 let cross_max_size = constants.max_size.cross(constants.dir);
1375 flex_lines[0].cross_size = node_size
1376 .cross(constants.dir)
1377 .maybe_clamp(cross_min_size, cross_max_size)
1378 .maybe_sub(cross_axis_padding_border)
1379 .maybe_max(0.0)
1380 .unwrap_or(0.0);
1381 } else {
1382 for line in flex_lines.iter_mut() {
1383 // 1. Collect all the flex items whose inline-axis is parallel to the main-axis, whose
1384 // align-self is baseline, and whose cross-axis margins are both non-auto. Find the
1385 // largest of the distances between each item’s baseline and its hypothetical outer
1386 // cross-start edge, and the largest of the distances between each item’s baseline
1387 // and its hypothetical outer cross-end edge, and sum these two values.
1388
1389 // 2. Among all the items not collected by the previous step, find the largest
1390 // outer hypothetical cross size.
1391
1392 // 3. The used cross-size of the flex line is the largest of the numbers found in the
1393 // previous two steps and zero.
1394
1395 let max_baseline: f32 = line.items.iter().map(|child| child.baseline).fold(0.0, |acc, x| acc.max(x));
1396 line.cross_size = line
1397 .items
1398 .iter()
1399 .map(|child| {
1400 if child.align_self == AlignSelf::Baseline
1401 && !child.margin_is_auto.cross_start(constants.dir)
1402 && !child.margin_is_auto.cross_end(constants.dir)
1403 {
1404 max_baseline - child.baseline + child.hypothetical_outer_size.cross(constants.dir)
1405 } else {
1406 child.hypothetical_outer_size.cross(constants.dir)
1407 }
1408 })
1409 .fold(0.0, |acc, x| acc.max(x));
1410 }
1411 }
1412}
1413
1414/// Handle 'align-content: stretch'.
1415///
1416/// # [9.4. Cross Size Determination](https://www.w3.org/TR/css-flexbox-1/#cross-sizing)
1417///
1418/// - [**Handle 'align-content: stretch'**](https://www.w3.org/TR/css-flexbox-1/#algo-line-stretch). If the flex container has a definite cross size, align-content is stretch,
1419/// and the sum of the flex lines' cross sizes is less than the flex container’s inner cross size,
1420/// increase the cross size of each flex line by equal amounts such that the sum of their cross sizes exactly equals the flex container’s inner cross size.
1421#[inline]
1422fn handle_align_content_stretch(flex_lines: &mut [FlexLine], node_size: Size<Option<f32>>, constants: &AlgoConstants) {
1423 if constants.align_content == AlignContent::Stretch {
1424 let cross_axis_padding_border = constants.padding_border.cross_axis_sum(constants.dir);
1425 let cross_min_size = constants.min_size.cross(constants.dir);
1426 let cross_max_size = constants.max_size.cross(constants.dir);
1427 let container_min_inner_cross = node_size
1428 .cross(constants.dir)
1429 .or(cross_min_size)
1430 .maybe_clamp(cross_min_size, cross_max_size)
1431 .maybe_sub(cross_axis_padding_border)
1432 .maybe_max(0.0)
1433 .unwrap_or(0.0);
1434
1435 let total_cross_axis_gap = sum_axis_gaps(constants.gap.cross(constants.dir), flex_lines.len());
1436 let lines_total_cross: f32 = flex_lines.iter().map(|line| line.cross_size).sum::<f32>() + total_cross_axis_gap;
1437
1438 if lines_total_cross < container_min_inner_cross {
1439 let remaining = container_min_inner_cross - lines_total_cross;
1440 let addition = remaining / flex_lines.len() as f32;
1441 flex_lines.iter_mut().for_each(|line| line.cross_size += addition);
1442 }
1443 }
1444}
1445
1446/// Determine the used cross size of each flex item.
1447///
1448/// # [9.4. Cross Size Determination](https://www.w3.org/TR/css-flexbox-1/#cross-sizing)
1449///
1450/// - [**Determine the used cross size of each flex item**](https://www.w3.org/TR/css-flexbox-1/#algo-stretch). If a flex item has align-self: stretch, its computed cross size property is auto,
1451/// and neither of its cross-axis margins are auto, the used outer cross size is the used cross size of its flex line, clamped according to the item’s used min and max cross sizes.
1452/// Otherwise, the used cross size is the item’s hypothetical cross size.
1453///
1454/// If the flex item has align-self: stretch, redo layout for its contents, treating this used size as its definite cross size so that percentage-sized children can be resolved.
1455///
1456/// **Note that this step does not affect the main size of the flex item, even if it has an intrinsic aspect ratio**.
1457#[inline]
1458fn determine_used_cross_size(tree: &impl LayoutTree, flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
1459 for line in flex_lines {
1460 let line_cross_size = line.cross_size;
1461
1462 for child in line.items.iter_mut() {
1463 let child_style = tree.style(child.node);
1464 child.target_size.set_cross(
1465 constants.dir,
1466 if child.align_self == AlignSelf::Stretch
1467 && !child.margin_is_auto.cross_start(constants.dir)
1468 && !child.margin_is_auto.cross_end(constants.dir)
1469 && child_style.size.cross(constants.dir) == Dimension::Auto
1470 {
1471 // For some reason this particular usage of max_width is an exception to the rule that max_width's transfer
1472 // using the aspect_ratio (if set). Both Chrome and Firefox agree on this. And reading the spec, it seems like
1473 // a reasonable interpretation. Although it seems to me that the spec *should* apply aspect_ratio here.
1474 let max_size_ignoring_aspect_ratio = child_style.max_size.maybe_resolve(constants.node_inner_size);
1475
1476 (line_cross_size - child.margin.cross_axis_sum(constants.dir)).maybe_clamp(
1477 child.min_size.cross(constants.dir),
1478 max_size_ignoring_aspect_ratio.cross(constants.dir),
1479 )
1480 } else {
1481 child.hypothetical_inner_size.cross(constants.dir)
1482 },
1483 );
1484
1485 child.outer_target_size.set_cross(
1486 constants.dir,
1487 child.target_size.cross(constants.dir) + child.margin.cross_axis_sum(constants.dir),
1488 );
1489 }
1490 }
1491}
1492
1493/// Distribute any remaining free space.
1494///
1495/// # [9.5. Main-Axis Alignment](https://www.w3.org/TR/css-flexbox-1/#main-alignment)
1496///
1497/// - [**Distribute any remaining free space**](https://www.w3.org/TR/css-flexbox-1/#algo-main-align). For each flex line:
1498///
1499/// 1. If the remaining free space is positive and at least one main-axis margin on this line is `auto`, distribute the free space equally among these margins.
1500/// Otherwise, set all `auto` margins to zero.
1501///
1502/// 2. Align the items along the main-axis per `justify-content`.
1503#[inline]
1504fn distribute_remaining_free_space(flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
1505 for line in flex_lines {
1506 let total_main_axis_gap = sum_axis_gaps(constants.gap.main(constants.dir), line.items.len());
1507 let used_space: f32 = total_main_axis_gap
1508 + line.items.iter().map(|child| child.outer_target_size.main(constants.dir)).sum::<f32>();
1509 let free_space = constants.inner_container_size.main(constants.dir) - used_space;
1510 let mut num_auto_margins = 0;
1511
1512 for child in line.items.iter_mut() {
1513 if child.margin_is_auto.main_start(constants.dir) {
1514 num_auto_margins += 1;
1515 }
1516 if child.margin_is_auto.main_end(constants.dir) {
1517 num_auto_margins += 1;
1518 }
1519 }
1520
1521 if free_space > 0.0 && num_auto_margins > 0 {
1522 let margin = free_space / num_auto_margins as f32;
1523
1524 for child in line.items.iter_mut() {
1525 if child.margin_is_auto.main_start(constants.dir) {
1526 if constants.is_row {
1527 child.margin.left = margin;
1528 } else {
1529 child.margin.top = margin;
1530 }
1531 }
1532 if child.margin_is_auto.main_end(constants.dir) {
1533 if constants.is_row {
1534 child.margin.right = margin;
1535 } else {
1536 child.margin.bottom = margin;
1537 }
1538 }
1539 }
1540 } else {
1541 let num_items = line.items.len();
1542 let layout_reverse = constants.dir.is_reverse();
1543 let gap = constants.gap.main(constants.dir);
1544 let justify_content_mode = constants.justify_content.unwrap_or(JustifyContent::FlexStart);
1545
1546 let justify_item = |(i, child): (usize, &mut FlexItem)| {
1547 child.offset_main =
1548 compute_alignment_offset(free_space, num_items, gap, justify_content_mode, layout_reverse, i == 0);
1549 };
1550
1551 if layout_reverse {
1552 line.items.iter_mut().rev().enumerate().for_each(justify_item);
1553 } else {
1554 line.items.iter_mut().enumerate().for_each(justify_item);
1555 }
1556 }
1557 }
1558}
1559
1560/// Resolve cross-axis `auto` margins.
1561///
1562/// # [9.6. Cross-Axis Alignment](https://www.w3.org/TR/css-flexbox-1/#cross-alignment)
1563///
1564/// - [**Resolve cross-axis `auto` margins**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-margins).
1565/// If a flex item has auto cross-axis margins:
1566///
1567/// - If its outer cross size (treating those auto margins as zero) is less than the cross size of its flex line,
1568/// distribute the difference in those sizes equally to the auto margins.
1569///
1570/// - Otherwise, if the block-start or inline-start margin (whichever is in the cross axis) is auto, set it to zero.
1571/// Set the opposite margin so that the outer cross size of the item equals the cross size of its flex line.
1572#[inline]
1573fn resolve_cross_axis_auto_margins(flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
1574 for line in flex_lines {
1575 let line_cross_size = line.cross_size;
1576 let max_baseline: f32 = line.items.iter_mut().map(|child| child.baseline).fold(0.0, |acc, x| acc.max(x));
1577
1578 for child in line.items.iter_mut() {
1579 let free_space = line_cross_size - child.outer_target_size.cross(constants.dir);
1580
1581 if child.margin_is_auto.cross_start(constants.dir) && child.margin_is_auto.cross_end(constants.dir) {
1582 if constants.is_row {
1583 child.margin.top = free_space / 2.0;
1584 child.margin.bottom = free_space / 2.0;
1585 } else {
1586 child.margin.left = free_space / 2.0;
1587 child.margin.right = free_space / 2.0;
1588 }
1589 } else if child.margin_is_auto.cross_start(constants.dir) {
1590 if constants.is_row {
1591 child.margin.top = free_space;
1592 } else {
1593 child.margin.left = free_space;
1594 }
1595 } else if child.margin_is_auto.cross_end(constants.dir) {
1596 if constants.is_row {
1597 child.margin.bottom = free_space;
1598 } else {
1599 child.margin.right = free_space;
1600 }
1601 } else {
1602 // 14. Align all flex items along the cross-axis.
1603 child.offset_cross = align_flex_items_along_cross_axis(child, free_space, max_baseline, constants);
1604 }
1605 }
1606 }
1607}
1608
1609/// Align all flex items along the cross-axis.
1610///
1611/// # [9.6. Cross-Axis Alignment](https://www.w3.org/TR/css-flexbox-1/#cross-alignment)
1612///
1613/// - [**Align all flex items along the cross-axis**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-align) per `align-self`,
1614/// if neither of the item's cross-axis margins are `auto`.
1615#[inline]
1616fn align_flex_items_along_cross_axis(
1617 child: &FlexItem,
1618 free_space: f32,
1619 max_baseline: f32,
1620 constants: &AlgoConstants,
1621) -> f32 {
1622 match child.align_self {
1623 AlignSelf::Start => 0.0,
1624 AlignSelf::FlexStart => {
1625 if constants.is_wrap_reverse {
1626 free_space
1627 } else {
1628 0.0
1629 }
1630 }
1631 AlignSelf::End => free_space,
1632 AlignSelf::FlexEnd => {
1633 if constants.is_wrap_reverse {
1634 0.0
1635 } else {
1636 free_space
1637 }
1638 }
1639 AlignSelf::Center => free_space / 2.0,
1640 AlignSelf::Baseline => {
1641 if constants.is_row {
1642 max_baseline - child.baseline
1643 } else {
1644 // Until we support vertical writing modes, baseline alignment only makes sense if
1645 // the constants.direction is row, so we treat it as flex-start alignment in columns.
1646 if constants.is_wrap_reverse {
1647 free_space
1648 } else {
1649 0.0
1650 }
1651 }
1652 }
1653 AlignSelf::Stretch => {
1654 if constants.is_wrap_reverse {
1655 free_space
1656 } else {
1657 0.0
1658 }
1659 }
1660 }
1661}
1662
1663/// Determine the flex container’s used cross size.
1664///
1665/// # [9.6. Cross-Axis Alignment](https://www.w3.org/TR/css-flexbox-1/#cross-alignment)
1666///
1667/// - [**Determine the flex container’s used cross size**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-container):
1668///
1669/// - If the cross size property is a definite size, use that, clamped by the used min and max cross sizes of the flex container.
1670///
1671/// - Otherwise, use the sum of the flex lines' cross sizes, clamped by the used min and max cross sizes of the flex container.
1672#[inline]
1673#[must_use]
1674fn determine_container_cross_size(
1675 flex_lines: &[FlexLine],
1676 node_size: Size<Option<f32>>,
1677 constants: &mut AlgoConstants,
1678) -> f32 {
1679 let total_cross_axis_gap = sum_axis_gaps(constants.gap.cross(constants.dir), flex_lines.len());
1680 let total_line_cross_size: f32 = flex_lines.iter().map(|line| line.cross_size).sum::<f32>();
1681
1682 let padding_border_sum = constants.padding_border.cross_axis_sum(constants.dir);
1683 let min_cross_size = constants.min_size.cross(constants.dir);
1684 let max_cross_size = constants.max_size.cross(constants.dir);
1685 let outer_container_size = node_size
1686 .cross(constants.dir)
1687 .unwrap_or(total_line_cross_size + total_cross_axis_gap + padding_border_sum)
1688 .maybe_clamp(min_cross_size, max_cross_size)
1689 .max(padding_border_sum);
1690 let inner_container_size = outer_container_size - padding_border_sum;
1691
1692 constants.container_size.set_cross(constants.dir, outer_container_size);
1693 constants.inner_container_size.set_cross(constants.dir, inner_container_size);
1694
1695 total_line_cross_size
1696}
1697
1698/// Align all flex lines per `align-content`.
1699///
1700/// # [9.6. Cross-Axis Alignment](https://www.w3.org/TR/css-flexbox-1/#cross-alignment)
1701///
1702/// - [**Align all flex lines**](https://www.w3.org/TR/css-flexbox-1/#algo-line-align) per `align-content`.
1703#[inline]
1704fn align_flex_lines_per_align_content(flex_lines: &mut [FlexLine], constants: &AlgoConstants, total_cross_size: f32) {
1705 let num_lines = flex_lines.len();
1706 let gap = constants.gap.cross(constants.dir);
1707 let align_content_mode = constants.align_content;
1708 let total_cross_axis_gap = sum_axis_gaps(gap, num_lines);
1709 let free_space = constants.inner_container_size.cross(constants.dir) - total_cross_size - total_cross_axis_gap;
1710
1711 let align_line = |(i, line): (usize, &mut FlexLine)| {
1712 line.offset_cross =
1713 compute_alignment_offset(free_space, num_lines, gap, align_content_mode, constants.is_wrap_reverse, i == 0);
1714 };
1715
1716 if constants.is_wrap_reverse {
1717 flex_lines.iter_mut().rev().enumerate().for_each(align_line);
1718 } else {
1719 flex_lines.iter_mut().enumerate().for_each(align_line);
1720 }
1721}
1722
1723/// Calculates the layout for a flex-item
1724#[allow(clippy::too_many_arguments)]
1725fn calculate_flex_item(
1726 tree: &mut impl LayoutTree,
1727 node: Node,
1728 item: &mut FlexItem,
1729 total_offset_main: &mut f32,
1730 total_offset_cross: f32,
1731 line_offset_cross: f32,
1732 container_size: Size<f32>,
1733 node_inner_size: Size<Option<f32>>,
1734 direction: FlexDirection,
1735) {
1736 let preliminary_size_and_baselines = GenericAlgorithm::perform_layout(
1737 tree,
1738 item.node,
1739 item.target_size.map(|s| s.into()),
1740 node_inner_size,
1741 container_size.map(|s| s.into()),
1742 SizingMode::ContentSize,
1743 );
1744 let preliminary_size = preliminary_size_and_baselines.size;
1745
1746 let offset_main = *total_offset_main
1747 + item.offset_main
1748 + item.margin.main_start(direction)
1749 + (item.inset.main_start(direction).or(item.inset.main_end(direction).map(|pos| -pos)).unwrap_or(0.0));
1750
1751 let offset_cross = total_offset_cross
1752 + item.offset_cross
1753 + line_offset_cross
1754 + item.margin.cross_start(direction)
1755 + (item.inset.cross_start(direction).or(item.inset.cross_end(direction).map(|pos| -pos)).unwrap_or(0.0));
1756
1757 if direction.is_row() {
1758 let baseline_offset_cross = total_offset_cross + item.offset_cross + item.margin.cross_start(direction);
1759 let inner_baseline = preliminary_size_and_baselines.first_baselines.y.unwrap_or(preliminary_size.height);
1760 item.baseline = baseline_offset_cross + inner_baseline;
1761 } else {
1762 let baseline_offset_main = *total_offset_main + item.offset_main + item.margin.main_start(direction);
1763 let inner_baseline = preliminary_size_and_baselines.first_baselines.y.unwrap_or(preliminary_size.height);
1764 item.baseline = baseline_offset_main + inner_baseline;
1765 }
1766
1767 let order = tree.children(node).position(|n| *n == item.node).unwrap() as u32;
1768
1769 *tree.layout_mut(item.node) = Layout {
1770 order,
1771 size: preliminary_size_and_baselines.size,
1772 location: Point {
1773 x: if direction.is_row() { offset_main } else { offset_cross },
1774 y: if direction.is_column() { offset_main } else { offset_cross },
1775 },
1776 };
1777
1778 *total_offset_main += item.offset_main + item.margin.main_axis_sum(direction) + preliminary_size.main(direction);
1779}
1780
1781/// Calculates the layout line
1782#[allow(clippy::too_many_arguments)]
1783fn calculate_layout_line(
1784 tree: &mut impl LayoutTree,
1785 node: Node,
1786 line: &mut FlexLine,
1787 total_offset_cross: &mut f32,
1788 container_size: Size<f32>,
1789 node_inner_size: Size<Option<f32>>,
1790 padding_border: Rect<f32>,
1791 direction: FlexDirection,
1792) {
1793 let mut total_offset_main = padding_border.main_start(direction);
1794 let line_offset_cross = line.offset_cross;
1795
1796 if direction.is_reverse() {
1797 for item in line.items.iter_mut().rev() {
1798 calculate_flex_item(
1799 tree,
1800 node,
1801 item,
1802 &mut total_offset_main,
1803 *total_offset_cross,
1804 line_offset_cross,
1805 container_size,
1806 node_inner_size,
1807 direction,
1808 );
1809 }
1810 } else {
1811 for item in line.items.iter_mut() {
1812 calculate_flex_item(
1813 tree,
1814 node,
1815 item,
1816 &mut total_offset_main,
1817 *total_offset_cross,
1818 line_offset_cross,
1819 container_size,
1820 node_inner_size,
1821 direction,
1822 );
1823 }
1824 }
1825
1826 *total_offset_cross += line_offset_cross + line.cross_size;
1827}
1828
1829/// Do a final layout pass and collect the resulting layouts.
1830#[inline]
1831fn final_layout_pass(tree: &mut impl LayoutTree, node: Node, flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
1832 let mut total_offset_cross = constants.padding_border.cross_start(constants.dir);
1833
1834 if constants.is_wrap_reverse {
1835 for line in flex_lines.iter_mut().rev() {
1836 calculate_layout_line(
1837 tree,
1838 node,
1839 line,
1840 &mut total_offset_cross,
1841 constants.container_size,
1842 constants.node_inner_size,
1843 constants.padding_border,
1844 constants.dir,
1845 );
1846 }
1847 } else {
1848 for line in flex_lines.iter_mut() {
1849 calculate_layout_line(
1850 tree,
1851 node,
1852 line,
1853 &mut total_offset_cross,
1854 constants.container_size,
1855 constants.node_inner_size,
1856 constants.padding_border,
1857 constants.dir,
1858 );
1859 }
1860 }
1861}
1862
1863/// Perform absolute layout on all absolutely positioned children.
1864#[inline]
1865fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node: Node, constants: &AlgoConstants) {
1866 let container_width = constants.container_size.width;
1867 let container_height = constants.container_size.height;
1868
1869 for order in 0..tree.child_count(node) {
1870 let child = tree.child(node, order);
1871 let child_style = tree.style(child);
1872
1873 // Skip items that are display:none or are not position:absolute
1874 if child_style.display == Display::None || child_style.position != Position::Absolute {
1875 continue;
1876 }
1877
1878 let aspect_ratio = child_style.aspect_ratio;
1879 let align_self = child_style.align_self.unwrap_or(constants.align_items);
1880 let margin = child_style.margin.map(|margin| margin.resolve_to_option(container_width));
1881 let padding = child_style.padding.resolve_or_zero(Some(container_width));
1882 let border = child_style.border.resolve_or_zero(Some(container_width));
1883 let padding_border_sum = (padding + border).sum_axes();
1884
1885 // Resolve inset
1886 let left = child_style.inset.left.maybe_resolve(container_width);
1887 let right = child_style.inset.right.maybe_resolve(container_width);
1888 let top = child_style.inset.top.maybe_resolve(container_height);
1889 let bottom = child_style.inset.bottom.maybe_resolve(container_height);
1890
1891 // Compute known dimensions from min/max/inherent size styles
1892 let style_size =
1893 child_style.size.maybe_resolve(constants.container_size).maybe_apply_aspect_ratio(aspect_ratio);
1894 let min_size = child_style
1895 .min_size
1896 .maybe_resolve(constants.container_size)
1897 .maybe_apply_aspect_ratio(aspect_ratio)
1898 .or(padding_border_sum.map(Some))
1899 .maybe_max(padding_border_sum);
1900 let max_size =
1901 child_style.max_size.maybe_resolve(constants.container_size).maybe_apply_aspect_ratio(aspect_ratio);
1902 let mut known_dimensions = style_size.maybe_clamp(min_size, max_size);
1903
1904 // Fill in width from left/right and reapply aspect ratio if:
1905 // - Width is not already known
1906 // - Item has both left and right inset properties set
1907 if let (None, Some(left), Some(right)) = (known_dimensions.width, left, right) {
1908 let new_width_raw = container_width.maybe_sub(margin.left).maybe_sub(margin.right) - left - right;
1909 known_dimensions.width = Some(f32_max(new_width_raw, 0.0));
1910 known_dimensions = known_dimensions.maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size);
1911 }
1912
1913 // Fill in height from top/bottom and reapply aspect ratio if:
1914 // - Height is not already known
1915 // - Item has both top and bottom inset properties set
1916 if let (None, Some(top), Some(bottom)) = (known_dimensions.height, top, bottom) {
1917 let new_height_raw = container_height.maybe_sub(margin.top).maybe_sub(margin.bottom) - top - bottom;
1918 known_dimensions.height = Some(f32_max(new_height_raw, 0.0));
1919 known_dimensions = known_dimensions.maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size);
1920 }
1921
1922 let measured_size_and_baselines = GenericAlgorithm::perform_layout(
1923 tree,
1924 child,
1925 known_dimensions,
1926 constants.node_inner_size,
1927 Size {
1928 width: AvailableSpace::Definite(container_width.maybe_clamp(min_size.width, max_size.width)),
1929 height: AvailableSpace::Definite(container_height.maybe_clamp(min_size.height, max_size.height)),
1930 },
1931 SizingMode::ContentSize,
1932 );
1933 let measured_size = measured_size_and_baselines.size;
1934 let final_size = known_dimensions.unwrap_or(measured_size).maybe_clamp(min_size, max_size);
1935
1936 let non_auto_margin = margin.map(|m| m.unwrap_or(0.0));
1937
1938 let free_space = Size {
1939 width: constants.container_size.width - final_size.width - non_auto_margin.horizontal_axis_sum(),
1940 height: constants.container_size.height - final_size.height - non_auto_margin.vertical_axis_sum(),
1941 }
1942 .f32_max(Size::ZERO);
1943
1944 // Expand auto margins to fill available space
1945 let resolved_margin = {
1946 let auto_margin_size = Size {
1947 width: {
1948 let auto_margin_count = margin.left.is_none() as u8 + margin.right.is_none() as u8;
1949 if auto_margin_count > 0 {
1950 free_space.width / auto_margin_count as f32
1951 } else {
1952 0.0
1953 }
1954 },
1955 height: {
1956 let auto_margin_count = margin.top.is_none() as u8 + margin.bottom.is_none() as u8;
1957 if auto_margin_count > 0 {
1958 free_space.height / auto_margin_count as f32
1959 } else {
1960 0.0
1961 }
1962 },
1963 };
1964
1965 Rect {
1966 left: margin.left.unwrap_or(auto_margin_size.width),
1967 right: margin.right.unwrap_or(auto_margin_size.width),
1968 top: margin.top.unwrap_or(auto_margin_size.height),
1969 bottom: margin.bottom.unwrap_or(auto_margin_size.height),
1970 }
1971 };
1972
1973 // Determine flex-relative insets
1974 let (start_main, end_main) = if constants.is_row { (left, right) } else { (top, bottom) };
1975 let (start_cross, end_cross) = if constants.is_row { (top, bottom) } else { (left, right) };
1976
1977 // Apply main-axis alignment
1978 // let free_main_space = free_space.main(constants.dir) - resolved_margin.main_axis_sum(constants.dir);
1979 let offset_main = if let Some(start) = start_main {
1980 start + constants.border.main_start(constants.dir) + resolved_margin.main_start(constants.dir)
1981 } else if let Some(end) = end_main {
1982 constants.container_size.main(constants.dir)
1983 - constants.border.main_end(constants.dir)
1984 - final_size.main(constants.dir)
1985 - end
1986 - resolved_margin.main_end(constants.dir)
1987 } else {
1988 // Stretch is an invalid value for justify_content in the flexbox algorithm, so we
1989 // treat it as if it wasn't set (and thus we default to FlexStart behaviour)
1990 match (constants.justify_content.unwrap_or(JustifyContent::Start), constants.is_wrap_reverse) {
1991 (JustifyContent::SpaceBetween, _)
1992 | (JustifyContent::Start, _)
1993 | (JustifyContent::Stretch, false)
1994 | (JustifyContent::FlexStart, false)
1995 | (JustifyContent::FlexEnd, true) => {
1996 constants.padding_border.main_start(constants.dir) + resolved_margin.main_start(constants.dir)
1997 }
1998 (JustifyContent::End, _)
1999 | (JustifyContent::FlexEnd, false)
2000 | (JustifyContent::FlexStart, true)
2001 | (JustifyContent::Stretch, true) => {
2002 constants.container_size.main(constants.dir)
2003 - constants.padding_border.main_end(constants.dir)
2004 - final_size.main(constants.dir)
2005 - resolved_margin.main_end(constants.dir)
2006 }
2007 (JustifyContent::SpaceEvenly, _) | (JustifyContent::SpaceAround, _) | (JustifyContent::Center, _) => {
2008 (constants.container_size.main(constants.dir) + constants.padding_border.main_start(constants.dir)
2009 - constants.padding_border.main_end(constants.dir)
2010 - final_size.main(constants.dir)
2011 + resolved_margin.main_start(constants.dir)
2012 - resolved_margin.main_end(constants.dir))
2013 / 2.0
2014 }
2015 }
2016 };
2017
2018 // Apply cross-axis alignment
2019 // let free_cross_space = free_space.cross(constants.dir) - resolved_margin.cross_axis_sum(constants.dir);
2020 let offset_cross = if let Some(start) = start_cross {
2021 start + constants.border.cross_start(constants.dir) + resolved_margin.cross_start(constants.dir)
2022 } else if let Some(end) = end_cross {
2023 constants.container_size.cross(constants.dir)
2024 - constants.border.cross_end(constants.dir)
2025 - final_size.cross(constants.dir)
2026 - end
2027 - resolved_margin.cross_end(constants.dir)
2028 } else {
2029 match (align_self, constants.is_wrap_reverse) {
2030 // Stretch alignment does not apply to absolutely positioned items
2031 // See "Example 3" at https://www.w3.org/TR/css-flexbox-1/#abspos-items
2032 // Note: Stretch should be FlexStart not Start when we support both
2033 (AlignSelf::Start, _)
2034 | (AlignSelf::Baseline | AlignSelf::Stretch | AlignSelf::FlexStart, false)
2035 | (AlignSelf::FlexEnd, true) => {
2036 constants.padding_border.cross_start(constants.dir) + resolved_margin.cross_start(constants.dir)
2037 }
2038 (AlignSelf::End, _)
2039 | (AlignSelf::Baseline | AlignSelf::Stretch | AlignSelf::FlexStart, true)
2040 | (AlignSelf::FlexEnd, false) => {
2041 constants.container_size.cross(constants.dir)
2042 - constants.padding_border.cross_end(constants.dir)
2043 - final_size.cross(constants.dir)
2044 - resolved_margin.cross_end(constants.dir)
2045 }
2046 (AlignSelf::Center, _) => {
2047 (constants.container_size.cross(constants.dir)
2048 + constants.padding_border.cross_start(constants.dir)
2049 - constants.padding_border.cross_end(constants.dir)
2050 - final_size.cross(constants.dir)
2051 + resolved_margin.cross_start(constants.dir)
2052 - resolved_margin.cross_end(constants.dir))
2053 / 2.0
2054 }
2055 }
2056 };
2057
2058 *tree.layout_mut(child) = Layout {
2059 order: order as u32,
2060 size: final_size,
2061 location: Point {
2062 x: if constants.is_row { offset_main } else { offset_cross },
2063 y: if constants.is_column { offset_main } else { offset_cross },
2064 },
2065 };
2066 }
2067}
2068
2069/// Computes the total space taken up by gaps in an axis given:
2070/// - The size of each gap
2071/// - The number of items (children or flex-lines) between which there are gaps
2072#[inline(always)]
2073fn sum_axis_gaps(gap: f32, num_items: usize) -> f32 {
2074 // Gaps only exist between items, so...
2075 if num_items <= 1 {
2076 // ...if there are less than 2 items then there are no gaps
2077 0.0
2078 } else {
2079 // ...otherwise there are (num_items - 1) gaps
2080 gap * (num_items - 1) as f32
2081 }
2082}
2083
2084#[cfg(test)]
2085mod tests {
2086 #![allow(clippy::redundant_clone)]
2087
2088 use crate::{
2089 geometry::Size,
2090 math::MaybeMath,
2091 resolve::ResolveOrZero,
2092 style::{FlexWrap, Style},
2093 Taffy,
2094 };
2095
2096 // Make sure we get correct constants
2097 #[test]
2098 fn correct_constants() {
2099 let mut tree = Taffy::with_capacity(16);
2100
2101 let style = Style::default();
2102 let node_id = tree.new_leaf(style.clone()).unwrap();
2103
2104 let node_size = Size::NONE;
2105 let parent_size = Size::NONE;
2106
2107 let constants = super::compute_constants(tree.style(node_id).unwrap(), node_size, parent_size);
2108
2109 assert!(constants.dir == style.flex_direction);
2110 assert!(constants.is_row == style.flex_direction.is_row());
2111 assert!(constants.is_column == style.flex_direction.is_column());
2112 assert!(constants.is_wrap_reverse == (style.flex_wrap == FlexWrap::WrapReverse));
2113
2114 let margin = style.margin.resolve_or_zero(parent_size);
2115 assert_eq!(constants.margin, margin);
2116
2117 let border = style.border.resolve_or_zero(parent_size);
2118 let padding = style.padding.resolve_or_zero(parent_size);
2119 let padding_border = padding + border;
2120 assert_eq!(constants.border, border);
2121 assert_eq!(constants.padding_border, padding_border);
2122
2123 let inner_size = Size {
2124 width: node_size.width.maybe_sub(padding_border.horizontal_axis_sum()),
2125 height: node_size.height.maybe_sub(padding_border.vertical_axis_sum()),
2126 };
2127 assert_eq!(constants.node_inner_size, inner_size);
2128
2129 assert_eq!(constants.container_size, Size::zero());
2130 assert_eq!(constants.inner_container_size, Size::zero());
2131 }
2132}