Struct style::invalidation::element::state_and_attributes::StateAndAttrInvalidationProcessor

pub struct StateAndAttrInvalidationProcessor<'a, 'b: 'a, E: TElement> {
    shared_context: &'a SharedStyleContext<'b>,
    element: E,
    data: &'a mut ElementData,
    matching_context: MatchingContext<'a, E::Impl>,
    traversal_map: SiblingTraversalMap<E>,
}

An invalidation processor for style changes due to state and attribute changes.

Fields

shared_context: &'a SharedStyleContext<'b>

element: E

data: &'a mut ElementData

matching_context: MatchingContext<'a, E::Impl>

traversal_map: SiblingTraversalMap<E>

Implementations

impl<'a, 'b: 'a, E: TElement + 'b> StateAndAttrInvalidationProcessor<'a, 'b, E>

pub fn new( shared_context: &'a SharedStyleContext<'b>, element: E, data: &'a mut ElementData, selector_caches: &'a mut SelectorCaches, ) -> Self

Creates a new StateAndAttrInvalidationProcessor.

Trait Implementations

impl<'a, 'b: 'a, E> InvalidationProcessor<'a, 'a, E> for StateAndAttrInvalidationProcessor<'a, 'b, E>

where E: TElement + 'a,

fn invalidates_on_pseudo_element(&self) -> bool

We need to invalidate style on pseudo-elements, in order to process changes that could otherwise end up in ::before or ::after content being generated, and invalidate lazy pseudo caches.

fn check_outer_dependency( &mut self, dependency: &Dependency, element: E, ) -> bool

When a dependency from a :where or :is selector matches, it may still be the case that we don’t need to invalidate the full style. Consider the case of:

fn matching_context(&mut self) -> &mut MatchingContext<'a, E::Impl>

The matching context that should be used to process invalidations.

fn sibling_traversal_map(&self) -> &SiblingTraversalMap<E>

The traversal map that should be used to process invalidations.

fn collect_invalidations( &mut self, element: E, _self_invalidations: &mut InvalidationVector<'a>, descendant_invalidations: &mut DescendantInvalidationLists<'a>, sibling_invalidations: &mut InvalidationVector<'a>, ) -> bool

Collect invalidations for a given element’s descendants and siblings.

fn should_process_descendants(&mut self, element: E) -> bool

Returns whether the invalidation process should process the descendants of the given element.

fn recursion_limit_exceeded(&mut self, element: E)

Executes an arbitrary action when the recursion limit is exceded (if any).

fn invalidated_descendants(&mut self, element: E, child: E)

Executes an action when any descendant of Self is invalidated.

fn invalidated_self(&mut self, element: E)

Executes an action when Self is invalidated.

fn invalidated_sibling(&mut self, element: E, of: E)

Executes an action when sibling is invalidated as a sibling of of.

fn light_tree_only(&self) -> bool

Whether the invalidation processor only cares about light-tree descendants of a given element, that is, doesn’t invalidate pseudo-elements, NAC, shadow dom…

fn found_relative_selector_invalidation( &mut self, _element: E, _kind: RelativeDependencyInvalidationKind, _relative_dependency: &'a Dependency, )

Executes an action when an element in a relative selector is reached. Lets the dependency to be borrowed for further processing out of the invalidation traversal.