Struct style::properties::computed_value_flags::ComputedValueFlags

pub struct ComputedValueFlags { /* fields omitted */ }

Misc information about a given computed style.

All flags are currently inherited for text, pseudo elements, and anonymous boxes, see StyleBuilder::for_inheritance and its callsites. If we ever want to add some flags that shouldn't inherit for them, we might want to add a function to handle this.

Methods

impl ComputedValueFlags

pub const HAS_TEXT_DECORATION_LINES: ComputedValueFlags

HAS_TEXT_DECORATION_LINES: ComputedValueFlags = ComputedValueFlags{bits: 1 << 0,}

Whether the style or any of the ancestors has a text-decoration-line property that should get propagated to descendants.

text-decoration-line is a reset property, but gets propagated in the frame/box tree.

pub const SHOULD_SUPPRESS_LINEBREAK: ComputedValueFlags

SHOULD_SUPPRESS_LINEBREAK: ComputedValueFlags = ComputedValueFlags{bits: 1 << 1,}

Whether line break inside should be suppressed.

If this flag is set, the line should not be broken inside, which means inlines act as if nowrap is set,
element is suppressed, and blocks are inlinized.

This bit is propagated to all children of line participants. It is currently used by ruby to make its content unbreakable.

pub const IS_TEXT_COMBINED: ComputedValueFlags

IS_TEXT_COMBINED: ComputedValueFlags = ComputedValueFlags{bits: 1 << 2,}

A flag used to mark text that that has text-combine-upright.

This is used from Gecko's layout engine.

pub const IS_RELEVANT_LINK_VISITED: ComputedValueFlags

IS_RELEVANT_LINK_VISITED: ComputedValueFlags = ComputedValueFlags{bits: 1 << 3,}

A flag used to mark styles under a relevant link that is also visited.

pub const IS_IN_PSEUDO_ELEMENT_SUBTREE: ComputedValueFlags

IS_IN_PSEUDO_ELEMENT_SUBTREE: ComputedValueFlags = ComputedValueFlags{bits: 1 << 4,}

A flag used to mark styles which are a pseudo-element or under one.

pub const IS_IN_DISPLAY_NONE_SUBTREE: ComputedValueFlags

IS_IN_DISPLAY_NONE_SUBTREE: ComputedValueFlags = ComputedValueFlags{bits: 1 << 5,}

A flag used to mark styles which are in a display: none subtree, or under one.

pub const INHERITS_DISPLAY: ComputedValueFlags

INHERITS_DISPLAY: ComputedValueFlags = ComputedValueFlags{bits: 1 << 6,}

Whether this style inherits the display property.

This is important because it may affect our optimizations to avoid computing the style of pseudo-elements, given whether the pseudo-element is generated depends on the display value.

pub const INHERITS_CONTENT: ComputedValueFlags

INHERITS_CONTENT: ComputedValueFlags = ComputedValueFlags{bits: 1 << 7,}

Whether this style inherits the content property.

Important because of the same reason.

pub const INHERITS_RESET_STYLE: ComputedValueFlags

INHERITS_RESET_STYLE: ComputedValueFlags = ComputedValueFlags{bits: 1 << 8,}

Whether the child explicitly inherits any reset property.

pub const IS_STYLE_IF_VISITED: ComputedValueFlags

IS_STYLE_IF_VISITED: ComputedValueFlags = ComputedValueFlags{bits: 1 << 9,}

A flag to mark a style which is a visited style.

pub fn empty() -> ComputedValueFlags

Returns an empty set of flags.

pub fn all() -> ComputedValueFlags

Returns the set containing all flags.

pub fn bits(&self) -> u16

Returns the raw value of the flags currently stored.

pub fn from_bits(bits: u16) -> Option<ComputedValueFlags>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

pub fn from_bits_truncate(bits: u16) -> ComputedValueFlags

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

pub fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

pub fn is_all(&self) -> bool

Returns true if all flags are currently set.

pub fn intersects(&self, other: ComputedValueFlags) -> bool

Returns true if there are flags common to both self and other.

pub fn contains(&self, other: ComputedValueFlags) -> bool

Returns true all of the flags in other are contained within self.

pub fn insert(&mut self, other: ComputedValueFlags)

Inserts the specified flags in-place.

pub fn remove(&mut self, other: ComputedValueFlags)

Removes the specified flags in-place.

pub fn toggle(&mut self, other: ComputedValueFlags)

Toggles the specified flags in-place.

pub fn set(&mut self, other: ComputedValueFlags, value: bool)

Inserts or removes the specified flags depending on the passed value.

impl ComputedValueFlags

pub fn inherited(self) -> Self

Returns the flags that are inherited.

Trait Implementations

impl Copy for ComputedValueFlags

impl PartialEq for ComputedValueFlags

fn eq(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests for !=.

impl Eq for ComputedValueFlags

impl Clone for ComputedValueFlags

fn clone(&self) -> ComputedValueFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialOrd for ComputedValueFlags

fn partial_cmp(&self, __arg_0: &ComputedValueFlags) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &ComputedValueFlags) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Ord for ComputedValueFlags

fn cmp(&self, __arg_0: &ComputedValueFlags) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Hash for ComputedValueFlags

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Debug for ComputedValueFlags

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

Formats the value using the given formatter.

impl Binary for ComputedValueFlags

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

Formats the value using the given formatter.

impl Octal for ComputedValueFlags

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

Formats the value using the given formatter.

impl LowerHex for ComputedValueFlags

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

Formats the value using the given formatter.

impl UpperHex for ComputedValueFlags

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

Formats the value using the given formatter.

impl BitOr for ComputedValueFlags

type Output = ComputedValueFlags

The resulting type after applying the | operator.

fn bitor(self, other: ComputedValueFlags) -> ComputedValueFlags

Returns the union of the two sets of flags.

impl BitOrAssign for ComputedValueFlags

fn bitor_assign(&mut self, other: ComputedValueFlags)

Adds the set of flags.

impl BitXor for ComputedValueFlags

type Output = ComputedValueFlags

The resulting type after applying the ^ operator.

fn bitxor(self, other: ComputedValueFlags) -> ComputedValueFlags

Returns the left flags, but with all the right flags toggled.

impl BitXorAssign for ComputedValueFlags

fn bitxor_assign(&mut self, other: ComputedValueFlags)

Toggles the set of flags.

impl BitAnd for ComputedValueFlags

type Output = ComputedValueFlags

The resulting type after applying the & operator.

fn bitand(self, other: ComputedValueFlags) -> ComputedValueFlags

Returns the intersection between the two sets of flags.

impl BitAndAssign for ComputedValueFlags

fn bitand_assign(&mut self, other: ComputedValueFlags)

Disables all flags disabled in the set.

impl Sub for ComputedValueFlags

type Output = ComputedValueFlags

The resulting type after applying the - operator.

fn sub(self, other: ComputedValueFlags) -> ComputedValueFlags

Returns the set difference of the two sets of flags.

impl SubAssign for ComputedValueFlags

fn sub_assign(&mut self, other: ComputedValueFlags)

Disables all flags enabled in the set.

impl Not for ComputedValueFlags

type Output = ComputedValueFlags

The resulting type after applying the ! operator.

fn not(self) -> ComputedValueFlags

Returns the complement of this set of flags.

impl Extend<ComputedValueFlags> for ComputedValueFlags

fn extend<T: IntoIterator<Item = ComputedValueFlags>>(&mut self, iterator: T)

Extends a collection with the contents of an iterator.

impl FromIterator<ComputedValueFlags> for ComputedValueFlags

fn from_iter<T: IntoIterator<Item = ComputedValueFlags>>(
    iterator: T
) -> ComputedValueFlags

Creates a value from an iterator.