Struct layout_2020::positioned::PositioningContext

pub(crate) struct PositioningContext {
    for_nearest_positioned_ancestor: Option<Vec<HoistedAbsolutelyPositionedBox>>,
    for_nearest_containing_block_for_all_descendants: Vec<HoistedAbsolutelyPositionedBox>,
}

Fields

for_nearest_positioned_ancestor: Option<Vec<HoistedAbsolutelyPositionedBox>>

for_nearest_containing_block_for_all_descendants: Vec<HoistedAbsolutelyPositionedBox>

Implementations

impl PositioningContext

pub(crate) fn new_for_containing_block_for_all_descendants() -> Self

pub(crate) fn new_for_subtree( collects_for_nearest_positioned_ancestor: bool, ) -> Self

Create a PositioningContext to use for laying out a subtree. The idea is that when subtree layout is finished, the newly hoisted boxes can be processed (normally adjusting their static insets) and then appended to the parent PositioningContext.

pub(crate) fn collects_for_nearest_positioned_ancestor(&self) -> bool

pub(crate) fn new_for_style(style: &ComputedValues) -> Option<Self>

pub(crate) fn adjust_static_position_of_hoisted_fragments( &mut self, parent_fragment: &Fragment, index: PositioningContextLength, )

Absolute and fixed position fragments are hoisted up to their containing blocks from their tree position. When these fragments have static inset start positions, that position (relative to the ancestor containing block) needs to be included with the hoisted fragment so that it can be laid out properly at the containing block.

This function is used to update the static position of hoisted boxes added after the given index at every level of the fragment tree as the hoisted fragments move up to their containing blocks. Once an ancestor fragment is laid out, this function can be used to aggregate its offset to any descendent boxes that are being hoisted. In this case, the appropriate index to use is the result of PositioningContext::len() cached before laying out the Fragment.

pub(crate) fn adjust_static_position_of_hoisted_fragments_with_offset( &mut self, offset: &PhysicalVec<Au>, index: PositioningContextLength, )

See documentation for PositioningContext::adjust_static_position_of_hoisted_fragments.

pub(crate) fn layout_maybe_position_relative_fragment( &mut self, layout_context: &LayoutContext<'_>, containing_block: &ContainingBlock<'_>, style: &ComputedValues, fragment_layout_fn: impl FnOnce(&mut Self) -> BoxFragment, ) -> BoxFragment

Given fragment_layout_fn, a closure which lays out a fragment in a provided PositioningContext, create a new positioning context if necessary for the fragment and lay out the fragment and all its children. Returns the newly created BoxFragment.

pub fn layout_collected_children( &mut self, layout_context: &LayoutContext<'_>, new_fragment: &mut BoxFragment, )

pub(crate) fn push(&mut self, box_: HoistedAbsolutelyPositionedBox)

fn is_empty(&self) -> bool

pub(crate) fn append(&mut self, other: Self)

pub(crate) fn layout_initial_containing_block_children( &mut self, layout_context: &LayoutContext<'_>, initial_containing_block: &DefiniteContainingBlock<'_>, fragments: &mut Vec<ArcRefCell<Fragment>>, )

pub(crate) fn clear(&mut self)

pub(crate) fn len(&self) -> PositioningContextLength

Get the length of this PositioningContext.

pub(crate) fn truncate(&mut self, length: &PositioningContextLength)

Truncate this PositioningContext to the given PositioningContextLength. This is useful for “unhoisting” boxes in this context and returning it to the state at the time that PositioningContext::len() was called.