1use 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
59struct 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 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 )
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 let containing_block = &self.content_box_size_override;
130 let style = independent_context.style();
131
132 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 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 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 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 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 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 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 )
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 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 depends_on_block_constraints: true,
355 }
356 }
357}
358
359impl TaffyContainer {
360 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 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 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 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}