Struct StyleRecalcChange 

pub struct StyleRecalcChange { /* private fields */ }

Tracks what kind of style recalculation is needed.

This is passed down through the style tree during recalc, allowing parent changes to inform child recalculation decisions.

Examples

// When parent's font-size changes:
let change = StyleRecalcChange::new(Propagate::InheritedOnly);

// When a class is applied:
let change = StyleRecalcChange::new(Propagate::RecalcChildren)
    .with_flags(RecalcFlags::CLASS_CHANGED);

// When dark mode toggles:
let change = StyleRecalcChange::new(Propagate::RecalcDescendants)
    .with_flags(RecalcFlags::DARK_MODE_CHANGED);

Implementations

impl StyleRecalcChange

pub const NONE: Self

No changes needed.

pub fn new(propagate: Propagate) -> Self

Create a new change with the specified propagation level.

pub fn with_flags(self, flags: RecalcFlags) -> Self

Add flags to this change.

pub fn propagate(&self) -> Propagate

Returns the propagation level.

pub fn flags(&self) -> RecalcFlags

Returns the flags.

pub fn is_empty(&self) -> bool

Returns true if no recalculation is needed.

pub fn for_children(&self) -> Self

Compute the change for processing children.

When moving from parent to child, we adjust the propagation level:

• RecalcDescendants stays the same (all descendants need recalc)
• RecalcChildren becomes None (only immediate children were marked)
• InheritedOnly stays the same (inherited props propagate)
• Other levels become None

pub fn combine(&self, other: &Self) -> Self

Combine two changes, taking the more intensive propagation.

When multiple sources contribute to a style change (e.g., both a class change and a hover state change), we need the union of their requirements.

pub fn ensure_at_least(&self, propagate: Propagate) -> Self

Upgrade to at least the given propagation level.

pub fn force_recalc_descendants(&self) -> Self

Force full descendant recalculation.

pub fn force_recalc_children(&self) -> Self

Force children to recalculate.

pub fn force_reattach(&self) -> Self

Mark as reattach needed.

pub fn should_recalc(&self, view_is_dirty: bool) -> bool

Should this view’s style be recalculated?

Returns true if either:

• The view itself is marked dirty
• The parent change requires recalculating children

pub fn can_use_inherited_fast_path(&self, view_has_selectors: bool) -> bool

Can we use the “inherited only” fast path?

Returns true if we only need to propagate inherited properties and can skip full selector resolution.

pub fn needs_reattach(&self) -> bool

Check if reattach is needed.

pub fn font_units_may_have_changed(&self) -> bool

Check if font-relative units may have changed.

Trait Implementations

impl Clone for StyleRecalcChange

fn clone(&self) -> StyleRecalcChange

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StyleRecalcChange

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

Formats the value using the given formatter.

impl Default for StyleRecalcChange

fn default() -> StyleRecalcChange

Returns the “default value” for a type.

impl Copy for StyleRecalcChange