Struct LayoutBoxBase 

pub(crate) struct LayoutBoxBase {
    pub base_fragment_info: BaseFragmentInfo,
    pub style: Arc<ComputedValues>,
    pub cached_inline_content_size: AtomicRefCell<Option<Box<(SizeConstraint, InlineContentSizesResult)>>>,
    pub outer_inline_content_sizes_depend_on_content: AtomicBool,
    cached_layout_result: AtomicRefCell<Option<LayoutResultAndInputs>>,
    cached_layout_result_dirty: AtomicBool,
    subtree_size: AtomicUsize,
    pub fragments: AtomicRefCell<Vec<Fragment>>,
    pub parent_box: Option<WeakLayoutBox>,
}

A box tree node that handles containing information about style and the original DOM node or pseudo-element that it is based on. This also handles caching of layout values such as the inline content sizes to avoid recalculating these values during layout passes.

In the future, this will hold layout results to support incremental layout.

Fields

base_fragment_info: BaseFragmentInfo

style: Arc<ComputedValues>

cached_inline_content_size: AtomicRefCell<Option<Box<(SizeConstraint, InlineContentSizesResult)>>>

outer_inline_content_sizes_depend_on_content: AtomicBool

cached_layout_result: AtomicRefCell<Option<LayoutResultAndInputs>>

The cached layout results for this LayoutBoxBase. These are either cached independent formatting context results or a cached block layout for use within a block flow.

cached_layout_result_dirty: AtomicBool

Whether or not the cached layout result for this LayoutBoxBase is dirty. This flag is used to preserve the cache when it can be used to do a faster layout, but cannot be reused directly.

subtree_size: AtomicUsize

A count of the number of boxes are in this box’s subtree (including itself). This is used as a heuristic to know when to perform parallel layout.

fragments: AtomicRefCell<Vec<Fragment>>

parent_box: Option<WeakLayoutBox>

Implementations

impl LayoutBoxBase

pub(crate) fn new( base_fragment_info: BaseFragmentInfo, style: ServoArc<ComputedValues>, ) -> Self

pub(crate) fn set_subtree_size(&self, size: usize)

Set the subtree size on this LayoutBoxBase. This should be done once box construction knows how many boxes are in this box’s subtree.

pub(crate) fn subtree_size(&self) -> usize

pub(crate) fn inline_content_sizes( &self, layout_context: &LayoutContext<'_>, constraint_space: &ConstraintSpace<'_>, layout_box: &impl ComputeInlineContentSizes, ) -> InlineContentSizesResult

Get the inline content sizes of a box tree node that extends this LayoutBoxBase, fetch the result from a cache when possible.

pub(crate) fn fragments(&self) -> AtomicRef<'_, Vec<Fragment>>

pub(crate) fn add_fragment(&self, fragment: Fragment)

pub(crate) fn set_fragment(&self, fragment: Fragment)

pub(crate) fn clear_fragments(&self)

pub(crate) fn clear_fragments_and_dirty_fragment_cache(&self)

Clear all resulting fragments and dirty and fragment caches. Resulting fragments are used for layout queries and fragment caches are used for incremental layout.

pub(crate) fn repair_style(&mut self, new_style: &ServoArc<ComputedValues>)

pub(crate) fn parent_box(&self) -> Option<LayoutBox>

pub(crate) fn invalidate_caches( &self, damage_set: &ElementDamageSet<'_>, ) -> bool

Clear fragment layout caches on this base, depending on upward flowing damage, but do not clear its resulting fragment. The layout cache itself is always cleared, but the inline content size cache is cleared conditionally.

Returns true is this LayoutBoxBase propagates RecomputeInlineContentSizes and false otherwise.

pub(crate) fn invalidate_caches_for_fragment_tree_layout( &self, damage_set: &ElementDamageSet<'_>, ) -> bool

Clear fragment layout caches on this base, depending on upward flowing damage, and also clear its resulting fragment. The layout cache itself is always cleared, but the inline content size cache is cleared conditionally.

Returns true is this LayoutBoxBase propagates RecomputeInlineContentSizes and false otherwise.

pub(crate) fn cached_independent_formatting_context_layout_if_applicable( &self, positioning_context: &mut PositioningContext, containing_block_for_children: &ContainingBlock<'_>, ) -> Option<IndependentFormattingContextLayoutResult>

pub(crate) fn cache_independent_formatting_context_layout( &self, containing_block_for_children: &ContainingBlock<'_>, child_positioning_context: &PositioningContext, result: &IndependentFormattingContextLayoutResult, )

pub(crate) fn cached_same_formatting_context_block_if_applicable( &self, containing_block: &ContainingBlock<'_>, collapsible_with_parent_start_margin: Option<CollapsibleWithParentStartMargin>, ignore_block_margins_for_stretch: LogicalSides1D<bool>, has_inline_parent: bool, ) -> Option<Arc<BoxFragment>>

pub(crate) fn cache_same_formatting_context_block_layout( &self, containing_block: &ContainingBlock<'_>, collapsible_with_parent_start_margin: Option<CollapsibleWithParentStartMargin>, ignore_block_margins_for_stretch: LogicalSides1D<bool>, has_inline_parent: bool, fragment: Arc<BoxFragment>, )

pub(crate) fn clear_scrollable_overflow_all_on_fragments(&self)

pub(crate) fn mark_fragments_as_descendants_changed(&self)

Trait Implementations

impl Debug for LayoutBoxBase

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl MallocSizeOf for LayoutBoxBase

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.