layout/taffy/
layout.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use app_units::Au;
6use atomic_refcell::{AtomicRef, AtomicRefCell};
7use style::properties::ComputedValues;
8use style::values::specified::align::AlignFlags;
9use style::values::specified::box_::DisplayInside;
10use style::{Atom, Zero};
11use taffy::style_helpers::{TaffyMaxContent, TaffyMinContent};
12use taffy::{AvailableSpace, MaybeMath, RequestedAxis, RunMode};
13
14use super::{
15    SpecificTaffyGridInfo, TaffyContainer, TaffyItemBox, TaffyItemBoxInner, TaffyStyloStyle,
16};
17use crate::cell::ArcRefCell;
18use crate::context::LayoutContext;
19use crate::formatting_contexts::{Baselines, IndependentFormattingContext};
20use crate::fragment_tree::{
21    BoxFragment, CollapsedBlockMargins, Fragment, FragmentFlags, SpecificLayoutInfo,
22};
23use crate::geom::{LogicalVec2, PhysicalPoint, PhysicalRect, PhysicalSides, PhysicalSize};
24use crate::layout_box_base::CacheableLayoutResult;
25use crate::positioned::{AbsolutelyPositionedBox, PositioningContext, PositioningContextLength};
26use crate::sizing::{
27    ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult, LazySize, SizeConstraint,
28};
29use crate::style_ext::LayoutStyle;
30use crate::{ConstraintSpace, ContainingBlock, ContainingBlockSize};
31
32const DUMMY_NODE_ID: taffy::NodeId = taffy::NodeId::new(u64::MAX);
33
34fn resolve_content_size(constraint: AvailableSpace, content_sizes: ContentSizes) -> f32 {
35    match constraint {
36        AvailableSpace::Definite(limit) => {
37            let min = content_sizes.min_content.to_f32_px();
38            let max = content_sizes.max_content.to_f32_px();
39            limit.min(max).max(min)
40        },
41        AvailableSpace::MinContent => content_sizes.min_content.to_f32_px(),
42        AvailableSpace::MaxContent => content_sizes.max_content.to_f32_px(),
43    }
44}
45
46#[inline(always)]
47fn with_independant_formatting_context<T>(
48    item: &mut TaffyItemBoxInner,
49    cb: impl FnOnce(&IndependentFormattingContext) -> T,
50) -> T {
51    match item {
52        TaffyItemBoxInner::InFlowBox(context) => cb(context),
53        TaffyItemBoxInner::OutOfFlowAbsolutelyPositionedBox(abspos_box) => {
54            cb(&AtomicRefCell::borrow(abspos_box).context)
55        },
56    }
57}
58
59/// Layout parameters and intermediate results about a taffy container,
60/// grouped to avoid passing around many parameters
61struct TaffyContainerContext<'a> {
62    source_child_nodes: &'a [ArcRefCell<TaffyItemBox>],
63    layout_context: &'a LayoutContext<'a>,
64    positioning_context: &'a mut PositioningContext,
65    content_box_size_override: &'a ContainingBlock<'a>,
66    style: &'a ComputedValues,
67    specific_layout_info: Option<SpecificLayoutInfo>,
68
69    /// Temporary location for children specific info, which will be moved into child fragments
70    child_specific_layout_infos: Vec<Option<SpecificLayoutInfo>>,
71}
72
73struct ChildIter(std::ops::Range<usize>);
74impl Iterator for ChildIter {
75    type Item = taffy::NodeId;
76    fn next(&mut self) -> Option<Self::Item> {
77        self.0.next().map(taffy::NodeId::from)
78    }
79}
80
81impl taffy::TraversePartialTree for TaffyContainerContext<'_> {
82    type ChildIter<'a>
83        = ChildIter
84    where
85        Self: 'a;
86
87    fn child_ids(&self, _node_id: taffy::NodeId) -> Self::ChildIter<'_> {
88        ChildIter(0..self.source_child_nodes.len())
89    }
90
91    fn child_count(&self, _node_id: taffy::NodeId) -> usize {
92        self.source_child_nodes.len()
93    }
94
95    fn get_child_id(&self, _node_id: taffy::NodeId, index: usize) -> taffy::NodeId {
96        taffy::NodeId::from(index)
97    }
98}
99
100impl taffy::LayoutPartialTree for TaffyContainerContext<'_> {
101    type CustomIdent = Atom;
102
103    type CoreContainerStyle<'a>
104        = TaffyStyloStyle<&'a ComputedValues>
105    where
106        Self: 'a;
107
108    fn get_core_container_style(&self, _node_id: taffy::NodeId) -> Self::CoreContainerStyle<'_> {
109        TaffyStyloStyle::new(self.style, false /* is_replaced */)
110    }
111
112    fn set_unrounded_layout(&mut self, node_id: taffy::NodeId, layout: &taffy::Layout) {
113        let id = usize::from(node_id);
114        (*self.source_child_nodes[id]).borrow_mut().taffy_layout = *layout;
115    }
116
117    fn compute_child_layout(
118        &mut self,
119        node_id: taffy::NodeId,
120        inputs: taffy::LayoutInput,
121    ) -> taffy::LayoutOutput {
122        let mut child = (*self.source_child_nodes[usize::from(node_id)]).borrow_mut();
123        let child = &mut *child;
124
125        with_independant_formatting_context(
126            &mut child.taffy_level_box,
127            |independent_context| -> taffy::LayoutOutput {
128                // TODO: re-evaluate sizing constraint conversions in light of recent layout changes
129                let containing_block = &self.content_box_size_override;
130                let style = independent_context.style();
131
132                // Adjust known_dimensions from border box to content box
133                let pbm = independent_context
134                    .layout_style()
135                    .padding_border_margin(containing_block);
136                let pb_sum = pbm.padding_border_sums.map(|v| v.to_f32_px());
137                let margin_sum = pbm.margin.auto_is(Au::zero).sum().map(|v| v.to_f32_px());
138                let content_box_inset = pb_sum + margin_sum;
139                let content_box_known_dimensions = taffy::Size {
140                    width: inputs
141                        .known_dimensions
142                        .width
143                        .map(|width| width - pb_sum.inline),
144                    height: inputs
145                        .known_dimensions
146                        .height
147                        .map(|height| height - pb_sum.block),
148                };
149                let preferred_aspect_ratio =
150                    independent_context.preferred_aspect_ratio(&pbm.padding_border_sums);
151
152                // TODO: pass min- and max- size
153                let tentative_block_size = content_box_known_dimensions
154                    .height
155                    .map(Au::from_f32_px)
156                    .map_or_else(SizeConstraint::default, SizeConstraint::Definite);
157
158                // Compute inline size
159                let inline_size = content_box_known_dimensions.width.unwrap_or_else(|| {
160                    let constraint_space = ConstraintSpace {
161                        block_size: tentative_block_size,
162                        style,
163                        preferred_aspect_ratio,
164                    };
165
166                    // TODO: pass min- and max- size
167                    let result = independent_context
168                        .inline_content_sizes(self.layout_context, &constraint_space);
169                    let adjusted_available_space = inputs
170                        .available_space
171                        .width
172                        .map_definite_value(|width| width - content_box_inset.inline);
173
174                    resolve_content_size(adjusted_available_space, result.sizes)
175                });
176
177                // Return early if only inline content sizes are requested
178                if inputs.run_mode == RunMode::ComputeSize &&
179                    inputs.axis == RequestedAxis::Horizontal
180                {
181                    return taffy::LayoutOutput::from_outer_size(taffy::Size {
182                        width: inline_size + pb_sum.inline,
183                        // If RequestedAxis is Horizontal then height will be ignored.
184                        height: 0.0,
185                    });
186                }
187
188                let content_box_size_override = ContainingBlock {
189                    size: ContainingBlockSize {
190                        inline: Au::from_f32_px(inline_size),
191                        block: tentative_block_size,
192                    },
193                    style,
194                };
195
196                let lazy_block_size = match content_box_known_dimensions.height {
197                    // FIXME: use the correct min/max sizes.
198                    None => LazySize::intrinsic(),
199                    Some(height) => Au::from_f32_px(height).into(),
200                };
201
202                child.positioning_context = PositioningContext::default();
203                let layout = independent_context.layout(
204                    self.layout_context,
205                    &mut child.positioning_context,
206                    &content_box_size_override,
207                    containing_block,
208                    preferred_aspect_ratio,
209                    &lazy_block_size,
210                );
211
212                child.child_fragments = layout.fragments;
213                self.child_specific_layout_infos[usize::from(node_id)] =
214                    layout.specific_layout_info;
215
216                let block_size = lazy_block_size
217                    .resolve(|| layout.content_block_size)
218                    .to_f32_px();
219
220                let computed_size = taffy::Size {
221                    width: inline_size + pb_sum.inline,
222                    height: block_size + pb_sum.block,
223                };
224                let size = inputs.known_dimensions.unwrap_or(computed_size);
225
226                taffy::LayoutOutput {
227                    size,
228                    first_baselines: taffy::Point {
229                        x: None,
230                        y: layout.baselines.first.map(|au| au.to_f32_px()),
231                    },
232                    ..taffy::LayoutOutput::DEFAULT
233                }
234            },
235        )
236    }
237}
238
239impl taffy::LayoutGridContainer for TaffyContainerContext<'_> {
240    type GridContainerStyle<'a>
241        = TaffyStyloStyle<&'a ComputedValues>
242    where
243        Self: 'a;
244
245    type GridItemStyle<'a>
246        = TaffyStyloStyle<AtomicRef<'a, ComputedValues>>
247    where
248        Self: 'a;
249
250    fn get_grid_container_style(
251        &self,
252        _node_id: taffy::prelude::NodeId,
253    ) -> Self::GridContainerStyle<'_> {
254        TaffyStyloStyle::new(self.style, false /* is_replaced */)
255    }
256
257    fn get_grid_child_style(
258        &self,
259        child_node_id: taffy::prelude::NodeId,
260    ) -> Self::GridItemStyle<'_> {
261        let id = usize::from(child_node_id);
262        let child = (*self.source_child_nodes[id]).borrow();
263        // TODO: account for non-replaced elements that are "compressible replaced"
264        let is_replaced = child.is_in_flow_replaced();
265        let stylo_style = AtomicRef::map(child, |c| &*c.style);
266        TaffyStyloStyle::new(stylo_style, is_replaced)
267    }
268
269    fn set_detailed_grid_info(
270        &mut self,
271        _node_id: taffy::NodeId,
272        specific_layout_info: taffy::DetailedGridInfo,
273    ) {
274        self.specific_layout_info = Some(SpecificLayoutInfo::Grid(Box::new(
275            SpecificTaffyGridInfo::from_detailed_grid_layout(specific_layout_info),
276        )));
277    }
278}
279
280impl ComputeInlineContentSizes for TaffyContainer {
281    fn compute_inline_content_sizes(
282        &self,
283        layout_context: &LayoutContext,
284        _constraint_space: &ConstraintSpace,
285    ) -> InlineContentSizesResult {
286        let style = &self.style;
287
288        let max_content_inputs = taffy::LayoutInput {
289            run_mode: taffy::RunMode::ComputeSize,
290            sizing_mode: taffy::SizingMode::InherentSize,
291            axis: taffy::RequestedAxis::Horizontal,
292            vertical_margins_are_collapsible: taffy::Line::FALSE,
293
294            known_dimensions: taffy::Size::NONE,
295            parent_size: taffy::Size::NONE,
296            available_space: taffy::Size::MAX_CONTENT,
297        };
298
299        let min_content_inputs = taffy::LayoutInput {
300            available_space: taffy::Size::MIN_CONTENT,
301            ..max_content_inputs
302        };
303
304        let containing_block = &ContainingBlock {
305            size: ContainingBlockSize {
306                inline: Au::zero(),
307                block: SizeConstraint::default(),
308            },
309            style,
310        };
311
312        let mut grid_context = TaffyContainerContext {
313            layout_context,
314            positioning_context: &mut PositioningContext::default(),
315            content_box_size_override: containing_block,
316            style,
317            source_child_nodes: &self.children,
318            specific_layout_info: None,
319            child_specific_layout_infos: vec![None; self.children.len()],
320        };
321
322        let (max_content_output, min_content_output) = match style.clone_display().inside() {
323            DisplayInside::Grid => {
324                let max_content_output = taffy::compute_grid_layout(
325                    &mut grid_context,
326                    DUMMY_NODE_ID,
327                    max_content_inputs,
328                );
329                let min_content_output = taffy::compute_grid_layout(
330                    &mut grid_context,
331                    DUMMY_NODE_ID,
332                    min_content_inputs,
333                );
334                (max_content_output, min_content_output)
335            },
336            _ => panic!("Servo is only configured to use Taffy for CSS Grid layout"),
337        };
338
339        let pb_sums = self
340            .layout_style()
341            .padding_border_margin(containing_block)
342            .padding_border_sums;
343
344        InlineContentSizesResult {
345            sizes: ContentSizes {
346                max_content: Au::from_f32_px(max_content_output.size.width) - pb_sums.inline,
347                min_content: Au::from_f32_px(min_content_output.size.width) - pb_sums.inline,
348            },
349
350            // TODO: determine this accurately
351            //
352            // "true" is a safe default as it will prevent Servo from performing optimizations based
353            // on the assumption that the node's size does not depend on block constraints.
354            depends_on_block_constraints: true,
355        }
356    }
357}
358
359impl TaffyContainer {
360    /// <https://drafts.csswg.org/css-grid/#layout-algorithm>
361    pub(crate) fn layout(
362        &self,
363        layout_context: &LayoutContext,
364        positioning_context: &mut PositioningContext,
365        content_box_size_override: &ContainingBlock,
366        containing_block: &ContainingBlock,
367    ) -> CacheableLayoutResult {
368        let mut container_ctx = TaffyContainerContext {
369            layout_context,
370            positioning_context,
371            content_box_size_override,
372            style: content_box_size_override.style,
373            source_child_nodes: &self.children,
374            specific_layout_info: None,
375            child_specific_layout_infos: vec![None; self.children.len()],
376        };
377
378        let container_style = &content_box_size_override.style;
379        let align_items = container_style.clone_align_items();
380        let justify_items = container_style.clone_justify_items();
381        let pbm = self.layout_style().padding_border_margin(containing_block);
382
383        let known_dimensions = taffy::Size {
384            width: Some(
385                (content_box_size_override.size.inline + pbm.padding_border_sums.inline)
386                    .to_f32_px(),
387            ),
388            height: content_box_size_override
389                .size
390                .block
391                .to_definite()
392                .map(Au::to_f32_px)
393                .maybe_add(pbm.padding_border_sums.block.to_f32_px()),
394        };
395
396        let taffy_containing_block = taffy::Size {
397            width: Some(containing_block.size.inline.to_f32_px()),
398            height: containing_block.size.block.to_definite().map(Au::to_f32_px),
399        };
400
401        let layout_input = taffy::LayoutInput {
402            run_mode: taffy::RunMode::PerformLayout,
403            sizing_mode: taffy::SizingMode::InherentSize,
404            axis: taffy::RequestedAxis::Vertical,
405            vertical_margins_are_collapsible: taffy::Line::FALSE,
406
407            known_dimensions,
408            parent_size: taffy_containing_block,
409            available_space: taffy_containing_block.map(AvailableSpace::from),
410        };
411
412        let output = match container_ctx.style.clone_display().inside() {
413            DisplayInside::Grid => {
414                taffy::compute_grid_layout(&mut container_ctx, DUMMY_NODE_ID, layout_input)
415            },
416            _ => panic!("Servo is only configured to use Taffy for CSS Grid layout"),
417        };
418
419        // Convert `taffy::Layout` into Servo `Fragment`s
420        // with container_ctx.child_specific_layout_infos will also moved to the corresponding `Fragment`s
421        let fragments: Vec<Fragment> = self
422            .children
423            .iter()
424            .map(|child| (**child).borrow_mut())
425            .enumerate()
426            .map(|(child_id, mut child)| {
427                fn rect_to_physical_sides<T>(rect: taffy::Rect<T>) -> PhysicalSides<T> {
428                    PhysicalSides::new(rect.top, rect.right, rect.bottom, rect.left)
429                }
430
431                fn size_and_pos_to_logical_rect<T: Default>(
432                    position: taffy::Point<T>,
433                    size: taffy::Size<T>,
434                ) -> PhysicalRect<T> {
435                    PhysicalRect::new(
436                        PhysicalPoint::new(position.x, position.y),
437                        PhysicalSize::new(size.width, size.height),
438                    )
439                }
440
441                let layout = &child.taffy_layout;
442
443                let padding = rect_to_physical_sides(layout.padding.map(Au::from_f32_px));
444                let border = rect_to_physical_sides(layout.border.map(Au::from_f32_px));
445                let margin = rect_to_physical_sides(layout.margin.map(Au::from_f32_px));
446
447                // Compute content box size and position.
448                //
449                // For the x/y position we have to correct for the difference between the
450                // content box and the border box for both the parent and the child.
451                let content_size = size_and_pos_to_logical_rect(
452                    taffy::Point {
453                        x: Au::from_f32_px(
454                            layout.location.x + layout.padding.left + layout.border.left,
455                        ) - pbm.padding.inline_start -
456                            pbm.border.inline_start,
457                        y: Au::from_f32_px(
458                            layout.location.y + layout.padding.top + layout.border.top,
459                        ) - pbm.padding.block_start -
460                            pbm.border.block_start,
461                    },
462                    taffy::Size {
463                        width: layout.size.width -
464                            layout.padding.left -
465                            layout.padding.right -
466                            layout.border.left -
467                            layout.border.right,
468                        height: layout.size.height -
469                            layout.padding.top -
470                            layout.padding.bottom -
471                            layout.border.top -
472                            layout.border.bottom,
473                    }
474                    .map(Au::from_f32_px),
475                );
476
477                let child_specific_layout_info: Option<SpecificLayoutInfo> =
478                    std::mem::take(&mut container_ctx.child_specific_layout_infos[child_id]);
479
480                let fragment = match &mut child.taffy_level_box {
481                    TaffyItemBoxInner::InFlowBox(independent_box) => {
482                        let mut fragment_info = independent_box.base_fragment_info();
483                        fragment_info
484                            .flags
485                            .insert(FragmentFlags::IS_FLEX_OR_GRID_ITEM);
486                        let mut box_fragment = BoxFragment::new(
487                            fragment_info,
488                            independent_box.style().clone(),
489                            std::mem::take(&mut child.child_fragments),
490                            content_size,
491                            padding,
492                            border,
493                            margin,
494                            child_specific_layout_info,
495                        )
496                        .with_baselines(Baselines {
497                            first: output.first_baselines.y.map(Au::from_f32_px),
498                            last: None,
499                        });
500
501                        child.positioning_context.layout_collected_children(
502                            container_ctx.layout_context,
503                            &mut box_fragment,
504                        );
505                        child
506                            .positioning_context
507                            .adjust_static_position_of_hoisted_fragments_with_offset(
508                                &box_fragment.content_rect.origin.to_vector(),
509                                PositioningContextLength::zero(),
510                            );
511                        container_ctx
512                            .positioning_context
513                            .append(std::mem::take(&mut child.positioning_context));
514
515                        Fragment::Box(ArcRefCell::new(box_fragment))
516                    },
517                    TaffyItemBoxInner::OutOfFlowAbsolutelyPositionedBox(abs_pos_box) => {
518                        fn resolve_alignment(value: AlignFlags, auto: AlignFlags) -> AlignFlags {
519                            match value {
520                                AlignFlags::AUTO => auto,
521                                AlignFlags::NORMAL => AlignFlags::STRETCH,
522                                value => value,
523                            }
524                        }
525
526                        let hoisted_box = AbsolutelyPositionedBox::to_hoisted(
527                            abs_pos_box.clone(),
528                            PhysicalRect::from_size(PhysicalSize::new(
529                                Au::from_f32_px(output.size.width),
530                                Au::from_f32_px(output.size.height),
531                            )),
532                            LogicalVec2 {
533                                inline: resolve_alignment(
534                                    child.style.clone_align_self().0.0,
535                                    align_items.0,
536                                ),
537                                block: resolve_alignment(
538                                    child.style.clone_justify_self().0.0,
539                                    justify_items.computed.0,
540                                ),
541                            },
542                            container_ctx.style.writing_mode,
543                        );
544                        let hoisted_fragment = hoisted_box.fragment.clone();
545                        container_ctx.positioning_context.push(hoisted_box);
546                        Fragment::AbsoluteOrFixedPositioned(hoisted_fragment)
547                    },
548                };
549
550                if let TaffyItemBoxInner::InFlowBox(independent_formatting_context) =
551                    &child.taffy_level_box
552                {
553                    independent_formatting_context
554                        .base
555                        .set_fragment(fragment.clone());
556                }
557                fragment
558            })
559            .collect();
560
561        CacheableLayoutResult {
562            fragments,
563            content_block_size: Au::from_f32_px(output.size.height) - pbm.padding_border_sums.block,
564            content_inline_size_for_table: None,
565            baselines: Baselines::default(),
566
567            // TODO: determine this accurately
568            //
569            // "true" is a safe default as it will prevent Servo from performing optimizations based
570            // on the assumption that the node's size does not depend on block constraints.
571            depends_on_block_constraints: true,
572            specific_layout_info: container_ctx.specific_layout_info,
573            collapsible_margins_in_children: CollapsedBlockMargins::zero(),
574        }
575    }
576
577    #[inline]
578    pub(crate) fn layout_style(&self) -> LayoutStyle<'_> {
579        LayoutStyle::Default(&self.style)
580    }
581}