Struct layout_2013::traversal::RecalcStyleAndConstructFlows

pub struct RecalcStyleAndConstructFlows<'a> {
    context: LayoutContext<'a>,
}

Fields

context: LayoutContext<'a>

Implementations

impl<'a> RecalcStyleAndConstructFlows<'a>

pub fn new(context: LayoutContext<'a>) -> Self

Creates a traversal context, taking ownership of the shared layout context.

pub fn context(&self) -> &LayoutContext<'a>

pub fn destroy(self) -> LayoutContext<'a>

Consumes this traversal context, returning ownership of the shared layout context to the caller.

Trait Implementations

impl<'a, 'dom, E> DomTraversal<E> for RecalcStyleAndConstructFlows<'a>

where E: TElement, E::ConcreteNode: LayoutNode<'dom>,

fn process_preorder<F>( &self, traversal_data: &PerLevelTraversalData, context: &mut StyleContext<'_, E>, node: E::ConcreteNode, note_child: F, )

where F: FnMut(E::ConcreteNode),

Process node on the way down, before its children have been processed.

fn process_postorder( &self, _style_context: &mut StyleContext<'_, E>, node: E::ConcreteNode, )

Process node on the way up, after its children have been processed.

fn text_node_needs_traversal( node: E::ConcreteNode, parent_data: &ElementData, ) -> bool

Returns true if traversal should visit a text node. The style system never processes text nodes, but Servo overrides this to visit them for flow construction when necessary.

fn shared_context(&self) -> &SharedStyleContext<'_>

Return the shared style context common to all worker threads.

fn needs_postorder_traversal() -> bool

Boolean that specifies whether a bottom up traversal should be performed.

fn handle_postorder_traversal( &self, context: &mut StyleContext<'_, E>, root: OpaqueNode, node: <E as TElement>::ConcreteNode, children_to_process: isize, )

Handles the postorder step of the traversal, if it exists, by bubbling up the parent chain.

fn pre_traverse( root: E, shared_context: &SharedStyleContext<'_>, ) -> PreTraverseToken<E>

Style invalidations happen when traversing from a parent to its children. However, this mechanism can’t handle style invalidations on the root. As such, we have a pre-traversal step to handle that part and determine whether a full traversal is needed.

fn element_needs_traversal( el: E, traversal_flags: TraversalFlags, data: Option<&ElementData>, ) -> bool

Returns true if traversal is needed for the given element and subtree.