1use std::sync::Arc;
6use std::sync::atomic::{AtomicBool, Ordering};
7
8use app_units::{Au, MAX_AU, MIN_AU};
9use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
10use euclid::Rect;
11use malloc_size_of_derive::MallocSizeOf;
12use once_cell::race::OnceBox;
13use servo_arc::Arc as ServoArc;
14use servo_base::id::{AtomicOptionScrollTreeNodeId, ScrollTreeNodeId};
15use servo_base::print_tree::PrintTree;
16use servo_geometry::f32_rect_to_au_rect;
17use style::Zero;
18use style::computed_values::border_collapse::T as BorderCollapse;
19use style::computed_values::overflow_x::T as ComputedOverflow;
20use style::logical_geometry::WritingMode;
21use style::properties::ComputedValues;
22
23use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment, FragmentFlags};
24use crate::SharedStyle;
25use crate::display_list::{ClipId, ToWebRender};
26use crate::formatting_contexts::Baselines;
27use crate::fragment_tree::{CumulativeContentRectCalculation, FragmentChildren};
28use crate::geom::{
29 AuOrAuto, LogicalSides, LogicalVec2, PhysicalPoint, PhysicalRect, PhysicalSides,
30 SyncPhysicalRectAu,
31};
32use crate::style_ext::ComputedValuesExt;
33use crate::table::SpecificTableGridInfo;
34use crate::taffy::SpecificTaffyGridInfo;
35
36#[derive(Clone, MallocSizeOf)]
38pub(crate) enum BackgroundMode {
39 Extra(Vec<ExtraBackground>),
42 None,
46 Normal,
48}
49
50#[derive(Clone, MallocSizeOf)]
51pub(crate) struct ExtraBackground {
52 pub style: SharedStyle,
53 pub rect: PhysicalRect<Au>,
54}
55
56#[derive(Clone, Debug, MallocSizeOf)]
57pub(crate) enum SpecificLayoutInfo {
58 Grid(Box<SpecificTaffyGridInfo>),
59 TableCellWithCollapsedBorders,
60 TableGridWithCollapsedBorders(Box<SpecificTableGridInfo>),
61 TableWrapper,
62}
63
64#[derive(Clone, MallocSizeOf)]
65pub(crate) struct BlockLevelLayoutInfo {
66 pub clearance: Option<Au>,
73
74 pub block_margins_collapsed_with_children: CollapsedBlockMargins,
75}
76
77#[derive(Clone, Default, MallocSizeOf)]
78pub(crate) struct BoxFragmentRareData {
79 pub(crate) resolved_sticky_insets: Option<Box<PhysicalSides<AuOrAuto>>>,
83
84 pub specific_layout_info: Option<SpecificLayoutInfo>,
86
87 pub generated_clip_id: Option<ClipId>,
90
91 pub generated_scroll_tree_node_id: Option<ScrollTreeNodeId>,
94}
95
96impl BoxFragmentRareData {
97 fn new(specific_layout_info: Option<SpecificLayoutInfo>) -> OnceBox<AtomicRefCell<Self>> {
100 specific_layout_info
101 .map(|info| {
102 OnceBox::with_value(Box::new(AtomicRefCell::new(BoxFragmentRareData {
103 resolved_sticky_insets: None,
104 specific_layout_info: Some(info),
105 generated_clip_id: None,
106 generated_scroll_tree_node_id: None,
107 })))
108 })
109 .unwrap_or_default()
110 }
111}
112
113#[derive(MallocSizeOf)]
114pub(crate) struct BoxFragment {
115 pub base: BaseFragment,
116
117 pub style: SharedStyle,
119
120 pub children: Vec<Fragment>,
121
122 pub cumulative_parent_content_rect: SyncPhysicalRectAu,
126
127 pub padding: PhysicalSides<Au>,
128 pub border: PhysicalSides<Au>,
129 pub margin: PhysicalSides<Au>,
130
131 baselines: Baselines,
135
136 scrollable_overflow: SyncPhysicalRectAu,
141 scrollable_overflow_is_up_to_date: AtomicBool,
142
143 pub background_mode: BackgroundMode,
144
145 pub rare_data: OnceBox<AtomicRefCell<BoxFragmentRareData>>,
147
148 pub block_level_layout_info: Option<Box<BlockLevelLayoutInfo>>,
150
151 pub spatial_tree_node: AtomicOptionScrollTreeNodeId,
156}
157
158impl BoxFragment {
159 #[expect(clippy::too_many_arguments)]
160 pub(crate) fn new(
161 base_fragment_info: BaseFragmentInfo,
162 style: ServoArc<ComputedValues>,
163 children: FragmentChildren,
164 content_rect: PhysicalRect<Au>,
165 padding: PhysicalSides<Au>,
166 border: PhysicalSides<Au>,
167 margin: PhysicalSides<Au>,
168 specific_layout_info: Option<SpecificLayoutInfo>,
169 ) -> Self {
170 let rare_data = BoxFragmentRareData::new(specific_layout_info);
171 let children = children.into_physical_fragments(
172 style.writing_mode,
173 LogicalVec2::from_physical_size(&content_rect.size, style.writing_mode),
174 );
175
176 Self {
177 base: BaseFragment::new(base_fragment_info, content_rect),
178 style: style.into(),
179 children,
180 cumulative_parent_content_rect: Default::default(),
181 padding,
182 border,
183 margin,
184 baselines: Baselines::default(),
185 scrollable_overflow: Default::default(),
186 scrollable_overflow_is_up_to_date: AtomicBool::new(false),
187 background_mode: BackgroundMode::Normal,
188 rare_data,
189 block_level_layout_info: None,
190 spatial_tree_node: Default::default(),
191 }
192 }
193
194 pub(crate) fn with_baselines(mut self, baselines: Baselines) -> Self {
195 self.baselines = baselines;
196 self
197 }
198
199 pub(crate) fn style<'a>(&'a self) -> AtomicRef<'a, ServoArc<ComputedValues>> {
200 self.style.borrow()
201 }
202
203 pub(crate) fn with_style(self: &Arc<Self>) -> BoxFragmentWithStyle<'_> {
204 BoxFragmentWithStyle {
205 box_fragment: self,
206 style: self.style(),
207 }
208 }
209
210 pub(crate) fn baselines(&self, writing_mode: WritingMode) -> Baselines {
213 let style = self.style();
214 let mut baselines = if writing_mode.is_horizontal() == style.writing_mode.is_horizontal() {
215 self.baselines
216 } else {
217 Baselines::default()
221 };
222
223 if style.establishes_scroll_container(self.base.flags) {
232 let content_rect_size =
233 LogicalVec2::from_physical_size(&self.content_rect().size, writing_mode);
234 let padding = LogicalSides::from_physical(&self.padding, writing_mode);
235 let border = LogicalSides::from_physical(&self.border, writing_mode);
236 let margin = LogicalSides::from_physical(&self.margin, writing_mode);
237 baselines.last = Some(
238 content_rect_size.block + padding.block_end + border.block_end + margin.block_end,
239 )
240 }
241 baselines
242 }
243
244 pub(crate) fn add_extra_background(&mut self, extra_background: ExtraBackground) {
245 match self.background_mode {
246 BackgroundMode::Extra(ref mut backgrounds) => backgrounds.push(extra_background),
247 _ => self.background_mode = BackgroundMode::Extra(vec![extra_background]),
248 }
249 }
250
251 pub(crate) fn set_does_not_paint_background(&mut self) {
252 self.background_mode = BackgroundMode::None;
253 }
254
255 pub(crate) fn ensure_rare_data(&self) -> AtomicRefMut<'_, BoxFragmentRareData> {
256 self.rare_data.get_or_init(Default::default).borrow_mut()
257 }
258
259 pub(crate) fn specific_layout_info(&self) -> Option<AtomicRef<'_, SpecificLayoutInfo>> {
260 let rare_data = self.rare_data.get()?.borrow();
261
262 AtomicRef::filter_map(rare_data, |rare_data| {
263 rare_data.specific_layout_info.as_ref()
264 })
265 }
266
267 pub(crate) fn clear_stacking_context_tree_traversal_data(&self) {
268 if let Some(rare_data) = self.rare_data.get() {
269 let mut rare_data = rare_data.borrow_mut();
270 rare_data.generated_clip_id = None;
271 rare_data.generated_scroll_tree_node_id = None;
272 rare_data.resolved_sticky_insets = None;
273 }
274 }
275
276 pub(crate) fn resolved_sticky_insets(
277 &self,
278 ) -> Option<AtomicRef<'_, Box<PhysicalSides<AuOrAuto>>>> {
279 let rare_data = self.rare_data.get()?.borrow();
280
281 AtomicRef::filter_map(rare_data, |rare_data| {
282 rare_data.resolved_sticky_insets.as_ref()
283 })
284 }
285
286 pub(crate) fn set_resolved_sticky_insets(&self, sticky_insets: PhysicalSides<AuOrAuto>) {
287 self.ensure_rare_data().resolved_sticky_insets = Some(sticky_insets.into());
288 }
289
290 pub(crate) fn generated_clip_id(&self) -> Option<ClipId> {
291 self.rare_data.get()?.borrow().generated_clip_id
292 }
293
294 pub(crate) fn set_generated_clip_id(&self, generated_clip_id: ClipId) {
295 self.ensure_rare_data().generated_clip_id = Some(generated_clip_id);
296 }
297
298 pub(crate) fn generated_scroll_tree_node_id(&self) -> Option<ScrollTreeNodeId> {
299 self.rare_data.get()?.borrow().generated_scroll_tree_node_id
300 }
301
302 pub(crate) fn set_generated_scroll_tree_node_id(
303 &self,
304 generated_scroll_tree_node_id: ScrollTreeNodeId,
305 ) {
306 self.ensure_rare_data().generated_scroll_tree_node_id = Some(generated_scroll_tree_node_id);
307 }
308
309 pub(crate) fn with_block_level_layout_info(
310 mut self,
311 block_margins_collapsed_with_children: CollapsedBlockMargins,
312 clearance: Option<Au>,
313 ) -> Self {
314 self.block_level_layout_info = Some(Box::new(BlockLevelLayoutInfo {
315 block_margins_collapsed_with_children,
316 clearance,
317 }));
318 self
319 }
320
321 pub(crate) fn clear_scrollable_overflow(&self) {
325 self.scrollable_overflow_is_up_to_date
326 .store(false, Ordering::Release);
327 }
328
329 #[inline]
330 pub(crate) fn set_cumulative_content_rect(&self, content_rect: &PhysicalRect<Au>) {
331 self.cumulative_parent_content_rect.set(*content_rect);
332 }
333
334 pub(crate) fn offset_by_cumulative_content_offset(
335 &self,
336 rect: &PhysicalRect<Au>,
337 cumulative_content_rect_calculation: CumulativeContentRectCalculation<'_>,
338 ) -> PhysicalRect<Au> {
339 cumulative_content_rect_calculation.ensure();
340 rect.translate(self.cumulative_parent_content_rect.origin().to_vector())
341 }
342
343 pub(crate) fn cumulative_content_box_rect(
344 &self,
345 cumulative_content_rect_calculation: CumulativeContentRectCalculation<'_>,
346 ) -> PhysicalRect<Au> {
347 self.offset_by_cumulative_content_offset(
348 &self.base.rect(),
349 cumulative_content_rect_calculation,
350 )
351 }
352
353 pub(crate) fn cumulative_padding_box_rect(
354 &self,
355 cumulative_content_rect_calculation: CumulativeContentRectCalculation<'_>,
356 ) -> PhysicalRect<Au> {
357 self.offset_by_cumulative_content_offset(
358 &self.padding_rect(),
359 cumulative_content_rect_calculation,
360 )
361 }
362
363 pub(crate) fn cumulative_border_box_rect(
364 &self,
365 cumulative_content_rect_calculation: CumulativeContentRectCalculation<'_>,
366 ) -> PhysicalRect<Au> {
367 self.offset_by_cumulative_content_offset(
368 &self.border_rect(),
369 cumulative_content_rect_calculation,
370 )
371 }
372
373 pub(crate) fn content_rect(&self) -> PhysicalRect<Au> {
374 self.base.rect()
375 }
376
377 pub(crate) fn padding_rect(&self) -> PhysicalRect<Au> {
378 self.content_rect().outer_rect(self.padding)
379 }
380
381 pub(crate) fn border_rect(&self) -> PhysicalRect<Au> {
382 self.padding_rect().outer_rect(self.border)
383 }
384
385 pub(crate) fn margin_rect(&self) -> PhysicalRect<Au> {
386 self.border_rect().outer_rect(self.margin)
387 }
388
389 pub(crate) fn padding_border_margin(&self) -> PhysicalSides<Au> {
390 self.margin + self.border + self.padding
391 }
392
393 pub(crate) fn is_root_element(&self) -> bool {
394 self.base.flags.intersects(FragmentFlags::IS_ROOT_ELEMENT)
395 }
396
397 pub(crate) fn is_body_element_of_html_element_root(&self) -> bool {
398 self.base
399 .flags
400 .intersects(FragmentFlags::IS_BODY_ELEMENT_OF_HTML_ELEMENT_ROOT)
401 }
402
403 pub(crate) fn print(self: &Arc<Self>, tree: &mut PrintTree) {
404 let with_style = self.with_style();
405 tree.new_level(format!(
406 "Box\
407 \nbase={:?}\
408 \ncontent={:?}\
409 \npadding rect={:?}\
410 \nborder rect={:?}\
411 \nmargin={:?}\
412 \nscrollable_overflow={:?}\
413 \nbaselines={:?}\
414 \noverflow={:?}",
415 self.base,
416 self.content_rect(),
417 self.padding_rect(),
418 self.border_rect(),
419 self.margin,
420 with_style.scrollable_overflow(),
421 self.baselines,
422 with_style.style().effective_overflow(self.base.flags),
423 ));
424
425 for child in &self.children {
426 child.print(tree);
427 }
428 tree.end_level();
429 }
430
431 pub(crate) fn is_flex_or_grid_item(&self) -> bool {
433 self.base
434 .flags
435 .contains(FragmentFlags::IS_FLEX_OR_GRID_ITEM)
436 }
437
438 pub(crate) fn is_replaced(&self) -> bool {
440 self.base.flags.contains(FragmentFlags::IS_REPLACED)
441 }
442
443 pub(crate) fn is_table_wrapper(&self) -> bool {
446 matches!(
447 self.specific_layout_info().as_deref(),
448 Some(SpecificLayoutInfo::TableWrapper)
449 )
450 }
451
452 pub(crate) fn is_table_grid_with_collapsed_borders(&self) -> bool {
454 matches!(
455 self.specific_layout_info().as_deref(),
456 Some(SpecificLayoutInfo::TableGridWithCollapsedBorders(_))
457 )
458 }
459
460 pub(crate) fn spatial_tree_node(&self) -> Option<ScrollTreeNodeId> {
461 self.spatial_tree_node.get()
462 }
463
464 pub(crate) fn containing_block_rect_for_absolute(
471 &self,
472 item_style: &ComputedValues,
473 ) -> PhysicalRect<Au> {
474 self.grid_info()
475 .map(|grid_info| {
476 grid_info.resolve_grid_area(self, item_style)
479 })
480 .unwrap_or_else(|| {
481 let mut padding_rect = self.padding_rect();
483 padding_rect.origin -= self.content_rect().origin.to_vector();
484 padding_rect
485 })
486 }
487
488 pub(crate) fn grid_info(&self) -> Option<AtomicRef<'_, SpecificTaffyGridInfo>> {
489 let rare_data = self.rare_data.get().map(|ref_cell| ref_cell.borrow());
490 rare_data.and_then(|rare_data| {
491 AtomicRef::filter_map(rare_data, |rare_data| {
492 match rare_data.specific_layout_info.as_ref() {
493 Some(SpecificLayoutInfo::Grid(grid_info)) => Some(&**grid_info),
494 _ => None,
495 }
496 })
497 })
498 }
499}
500
501pub(crate) struct BoxFragmentWithStyle<'a> {
508 pub(crate) box_fragment: &'a Arc<BoxFragment>,
509 pub(crate) style: AtomicRef<'a, ServoArc<ComputedValues>>,
510}
511
512impl std::ops::Deref for BoxFragmentWithStyle<'_> {
513 type Target = Arc<BoxFragment>;
514
515 fn deref(&self) -> &Self::Target {
516 self.box_fragment
517 }
518}
519
520impl<'a> BoxFragmentWithStyle<'a> {
521 pub(crate) fn style(&self) -> &ServoArc<ComputedValues> {
522 &self.style
523 }
524
525 pub(crate) fn clip_wholly_unreachable_scrollable_overflow(
530 &self,
531 scrollable_overflow_from_child: PhysicalRect<Au>,
532 clipping_rect: PhysicalRect<Au>,
533 ) -> PhysicalRect<Au> {
534 let scrolling_direction = self.style().overflow_direction();
543 let mut clipping_box = clipping_rect.to_box2d();
544 if scrolling_direction.rightward {
545 clipping_box.max.x = MAX_AU;
546 } else {
547 clipping_box.min.x = MIN_AU;
548 }
549
550 if scrolling_direction.downward {
551 clipping_box.max.y = MAX_AU;
552 } else {
553 clipping_box.min.y = MIN_AU;
554 }
555
556 let scrollable_overflow_box = scrollable_overflow_from_child
557 .to_box2d()
558 .intersection_unchecked(&clipping_box);
559
560 match scrollable_overflow_box.is_negative() {
561 false => scrollable_overflow_box.to_rect(),
562 true => Rect::zero(),
563 }
564 }
565
566 pub(crate) fn scrollable_overflow_for_parent(&self) -> PhysicalRect<Au> {
567 let style = self.style();
568 let mut overflow = self.border_rect();
569 if !style.establishes_scroll_container(self.base.flags) {
570 let scrollable_overflow = self.scrollable_overflow();
573 let bottom_right = PhysicalPoint::new(
574 overflow.max_x().max(scrollable_overflow.max_x()),
575 overflow.max_y().max(scrollable_overflow.max_y()),
576 );
577
578 let overflow_style = style.effective_overflow(self.base.flags);
579 if overflow_style.y == ComputedOverflow::Visible {
580 overflow.origin.y = overflow.origin.y.min(scrollable_overflow.origin.y);
581 overflow.size.height = bottom_right.y - overflow.origin.y;
582 }
583
584 if overflow_style.x == ComputedOverflow::Visible {
585 overflow.origin.x = overflow.origin.x.min(scrollable_overflow.origin.x);
586 overflow.size.width = bottom_right.x - overflow.origin.x;
587 }
588 }
589
590 if !style.has_effective_transform_or_perspective(self.base.flags) {
591 return overflow;
592 }
593
594 self.calculate_transform_matrix(&self.border_rect())
602 .and_then(|transform| {
603 transform.outer_transformed_rect(&overflow.to_webrender().to_rect())
604 })
605 .map(|transformed_rect| f32_rect_to_au_rect(transformed_rect).cast_unit())
606 .unwrap_or(overflow)
607 }
608
609 pub(crate) fn scrollable_overflow(&self) -> PhysicalRect<Au> {
613 if self
614 .scrollable_overflow_is_up_to_date
615 .load(Ordering::Acquire)
616 {
617 self.scrollable_overflow.get()
618 } else {
619 let rect = self.calculate_scrollable_overflow();
620 self.scrollable_overflow.set(rect);
621 self.scrollable_overflow_is_up_to_date
622 .store(true, Ordering::Release);
623 rect
624 }
625 }
626 fn calculate_scrollable_overflow(&self) -> PhysicalRect<Au> {
630 if self.base.flags.contains(FragmentFlags::IS_COLLAPSED) {
635 return Rect::zero();
636 }
637
638 let physical_padding_rect = self.padding_rect();
639 let content_origin = self.base.rect().origin.to_vector();
640
641 let mut scrollable_overflow =
665 self.children
666 .iter()
667 .fold(physical_padding_rect, |acc, child| {
668 let scrollable_overflow_from_child = child
669 .scrollable_overflow_for_parent()
670 .translate(content_origin);
671
672 let scrollable_overflow_from_child = self
677 .clip_wholly_unreachable_scrollable_overflow(
678 scrollable_overflow_from_child,
679 physical_padding_rect,
680 );
681
682 acc.union(&scrollable_overflow_from_child)
683 });
684
685 let should_include_additional_padding =
698 self.style().establishes_scroll_container(self.base.flags) &&
699 !self.base.flags.intersects(FragmentFlags::IS_INPUT_ELEMENT);
700
701 if should_include_additional_padding {
702 scrollable_overflow = self
703 .children
704 .iter()
705 .fold(scrollable_overflow, |acc, child| {
706 let Some(padding_contribution) =
707 child.scrollable_overflow_padding_contribution_for_parent()
708 else {
709 return acc;
710 };
711
712 let padding_contribution = padding_contribution
713 .translate(content_origin)
714 .outer_rect(self.padding);
715
716 let padding_contribution = self.clip_wholly_unreachable_scrollable_overflow(
720 padding_contribution,
721 physical_padding_rect,
722 );
723
724 acc.union(&padding_contribution)
725 });
726 }
727 scrollable_overflow
728 }
729
730 pub(crate) fn is_inline_box(&self) -> bool {
733 self.style().is_inline_box(self.base.flags)
734 }
735
736 pub(crate) fn is_atomic_inline_level(&self) -> bool {
739 self.style().is_atomic_inline_level(self.base.flags)
740 }
741
742 pub(crate) fn has_collapsed_borders(&self) -> bool {
743 match self.specific_layout_info().as_deref() {
744 Some(SpecificLayoutInfo::TableCellWithCollapsedBorders) => true,
745 Some(SpecificLayoutInfo::TableGridWithCollapsedBorders(_)) => true,
746 Some(SpecificLayoutInfo::TableWrapper) => {
747 self.style().get_inherited_table().border_collapse == BorderCollapse::Collapse
748 },
749 _ => false,
750 }
751 }
752
753 pub(crate) fn has_outline(&self) -> bool {
755 let style = self.style();
756 let outline = style.get_outline();
757 !outline.outline_style.none_or_hidden() && !outline.outline_width.0.is_zero()
758 }
759}