Enum style::properties::animated_properties::AnimationValue

pub enum AnimationValue {
    BackgroundColor(<T as ToAnimatedValue>::AnimatedValue),
    BackgroundImage(T),
    BackgroundPositionX(T),
    BackgroundPositionY(T),
    BackgroundRepeat(T),
    BackgroundAttachment(T),
    BackgroundClip(T),
    BackgroundOrigin(T),
    BackgroundSize(<T as ToAnimatedValue>::AnimatedValue),
    BorderTopColor(<T as ToAnimatedValue>::AnimatedValue),
    BorderTopStyle(T),
    BorderTopWidth(<T as ToAnimatedValue>::AnimatedValue),
    BorderLeftColor(<T as ToAnimatedValue>::AnimatedValue),
    BorderLeftStyle(T),
    BorderLeftWidth(<T as ToAnimatedValue>::AnimatedValue),
    BorderBottomColor(<T as ToAnimatedValue>::AnimatedValue),
    BorderBottomStyle(T),
    BorderBottomWidth(<T as ToAnimatedValue>::AnimatedValue),
    BorderRightColor(<T as ToAnimatedValue>::AnimatedValue),
    BorderRightStyle(T),
    BorderRightWidth(<T as ToAnimatedValue>::AnimatedValue),
    BorderTopLeftRadius(<T as ToAnimatedValue>::AnimatedValue),
    BorderTopRightRadius(<T as ToAnimatedValue>::AnimatedValue),
    BorderBottomRightRadius(<T as ToAnimatedValue>::AnimatedValue),
    BorderBottomLeftRadius(<T as ToAnimatedValue>::AnimatedValue),
    BorderImageSource(T),
    BorderImageOutset(T),
    BorderImageRepeat(T),
    BorderImageWidth(T),
    BorderImageSlice(T),
    Display(T),
    Position(T),
    Float(T),
    Clear(T),
    VerticalAlign(T),
    OverflowX(T),
    OverflowY(T),
    Transform(T),
    Perspective(T),
    PerspectiveOrigin(T),
    BackfaceVisibility(T),
    TransformStyle(T),
    TransformOrigin(T),
    Color(<T as ToAnimatedValue>::AnimatedValue),
    ColumnWidth(<T as ToAnimatedValue>::AnimatedValue),
    ColumnCount(<T as ToAnimatedValue>::AnimatedValue),
    ColumnGap(<T as ToAnimatedValue>::AnimatedValue),
    Content(T),
    CounterIncrement(T),
    CounterReset(T),
    Opacity(T),
    BoxShadow(<T as ToAnimatedValue>::AnimatedValue),
    Clip(T),
    Filter(<T as ToAnimatedValue>::AnimatedValue),
    MixBlendMode(T),
    FontFamily(T),
    FontStyle(T),
    FontVariantCaps(T),
    FontWeight(T),
    FontSize(<T as ToAnimatedValue>::AnimatedValue),
    FontStretch(T),
    Visibility(T),
    WritingMode(T),
    Direction(T),
    ImageRendering(T),
    BorderCollapse(T),
    EmptyCells(T),
    CaptionSide(T),
    BorderSpacing(<T as ToAnimatedValue>::AnimatedValue),
    LineHeight(<T as ToAnimatedValue>::AnimatedValue),
    TextTransform(T),
    TextIndent(T),
    OverflowWrap(T),
    WordBreak(T),
    TextJustify(T),
    TextAlign(T),
    LetterSpacing(T),
    WordSpacing(T),
    WhiteSpace(T),
    TextShadow(<T as ToAnimatedValue>::AnimatedValue),
    TextRendering(T),
    ListStylePosition(T),
    ListStyleType(T),
    ListStyleImage(T),
    Quotes(T),
    MarginTop(T),
    MarginLeft(T),
    MarginBottom(T),
    MarginRight(T),
    OutlineColor(<T as ToAnimatedValue>::AnimatedValue),
    OutlineStyle(T),
    OutlineWidth(<T as ToAnimatedValue>::AnimatedValue),
    OutlineOffset(T),
    PaddingTop(<T as ToAnimatedValue>::AnimatedValue),
    PaddingLeft(<T as ToAnimatedValue>::AnimatedValue),
    PaddingBottom(<T as ToAnimatedValue>::AnimatedValue),
    PaddingRight(<T as ToAnimatedValue>::AnimatedValue),
    Cursor(T),
    PointerEvents(T),
    Top(T),
    Left(T),
    Bottom(T),
    Right(T),
    ZIndex(T),
    FlexDirection(T),
    FlexWrap(T),
    JustifyContent(T),
    AlignContent(T),
    AlignItems(T),
    FlexGrow(<T as ToAnimatedValue>::AnimatedValue),
    FlexShrink(<T as ToAnimatedValue>::AnimatedValue),
    AlignSelf(T),
    Order(T),
    Width(T),
    MinWidth(T),
    MaxWidth(T),
    Height(T),
    MinHeight(T),
    MaxHeight(T),
    BoxSizing(T),
    TableLayout(T),
    TextOverflow(T),
    UnicodeBidi(T),
    TextDecorationLine(T),
}

An enum to represent a single computed value belonging to an animated property in order to be interpolated with another one. When interpolating, both values need to belong to the same property.

This is different to AnimatedProperty in the sense that AnimatedProperty also knows the final value to be used during the animation.

This is to be used in Gecko integration code.

FIXME: We need to add a path for custom properties, but that's trivial after this (is a similar path to that of PropertyDeclaration).

Variants

BackgroundColor(<T as ToAnimatedValue>::AnimatedValue)

background-color

BackgroundImage(T)

background-image

BackgroundPositionX(T)

background-position-x

BackgroundPositionY(T)

background-position-y

BackgroundRepeat(T)

background-repeat

BackgroundAttachment(T)

background-attachment

BackgroundClip(T)

background-clip

BackgroundOrigin(T)

background-origin

BackgroundSize(<T as ToAnimatedValue>::AnimatedValue)

background-size

BorderTopColor(<T as ToAnimatedValue>::AnimatedValue)

border-top-color

BorderTopStyle(T)

border-top-style

BorderTopWidth(<T as ToAnimatedValue>::AnimatedValue)

border-top-width

BorderLeftColor(<T as ToAnimatedValue>::AnimatedValue)

border-left-color

BorderLeftStyle(T)

border-left-style

BorderLeftWidth(<T as ToAnimatedValue>::AnimatedValue)

border-left-width

BorderBottomColor(<T as ToAnimatedValue>::AnimatedValue)

border-bottom-color

BorderBottomStyle(T)

border-bottom-style

BorderBottomWidth(<T as ToAnimatedValue>::AnimatedValue)

border-bottom-width

BorderRightColor(<T as ToAnimatedValue>::AnimatedValue)

border-right-color

BorderRightStyle(T)

border-right-style

BorderRightWidth(<T as ToAnimatedValue>::AnimatedValue)

border-right-width

BorderTopLeftRadius(<T as ToAnimatedValue>::AnimatedValue)

border-top-left-radius

BorderTopRightRadius(<T as ToAnimatedValue>::AnimatedValue)

border-top-right-radius

BorderBottomRightRadius(<T as ToAnimatedValue>::AnimatedValue)

border-bottom-right-radius

BorderBottomLeftRadius(<T as ToAnimatedValue>::AnimatedValue)

border-bottom-left-radius

BorderImageSource(T)

border-image-source

BorderImageOutset(T)

border-image-outset

BorderImageRepeat(T)

border-image-repeat

BorderImageWidth(T)

border-image-width

BorderImageSlice(T)

border-image-slice

Display(T)

display

Position(T)

position

Float(T)

float

Clear(T)

clear

VerticalAlign(T)

vertical-align

OverflowX(T)

overflow-x

OverflowY(T)

overflow-y

Transform(T)

transform

Perspective(T)

perspective

PerspectiveOrigin(T)

perspective-origin

BackfaceVisibility(T)

backface-visibility

TransformStyle(T)

transform-style

TransformOrigin(T)

transform-origin

Color(<T as ToAnimatedValue>::AnimatedValue)

color

ColumnWidth(<T as ToAnimatedValue>::AnimatedValue)

column-width

ColumnCount(<T as ToAnimatedValue>::AnimatedValue)

column-count

ColumnGap(<T as ToAnimatedValue>::AnimatedValue)

column-gap

Content(T)

content

CounterIncrement(T)

counter-increment

CounterReset(T)

counter-reset

Opacity(T)

opacity

BoxShadow(<T as ToAnimatedValue>::AnimatedValue)

box-shadow

Clip(T)

clip

Filter(<T as ToAnimatedValue>::AnimatedValue)

filter

MixBlendMode(T)

mix-blend-mode

FontFamily(T)

font-family

FontStyle(T)

font-style

FontVariantCaps(T)

font-variant-caps

FontWeight(T)

font-weight

FontSize(<T as ToAnimatedValue>::AnimatedValue)

font-size

FontStretch(T)

font-stretch

Visibility(T)

visibility

WritingMode(T)

writing-mode

Direction(T)

direction

ImageRendering(T)

image-rendering

BorderCollapse(T)

border-collapse

EmptyCells(T)

empty-cells

CaptionSide(T)

caption-side

BorderSpacing(<T as ToAnimatedValue>::AnimatedValue)

border-spacing

LineHeight(<T as ToAnimatedValue>::AnimatedValue)

line-height

TextTransform(T)

text-transform

TextIndent(T)

text-indent

OverflowWrap(T)

overflow-wrap

WordBreak(T)

word-break

TextJustify(T)

text-justify

TextAlign(T)

text-align

LetterSpacing(T)

letter-spacing

WordSpacing(T)

word-spacing

WhiteSpace(T)

white-space

TextShadow(<T as ToAnimatedValue>::AnimatedValue)

text-shadow

TextRendering(T)

text-rendering

ListStylePosition(T)

list-style-position

ListStyleType(T)

list-style-type

ListStyleImage(T)

list-style-image

Quotes(T)

quotes

MarginTop(T)

margin-top

MarginLeft(T)

margin-left

MarginBottom(T)

margin-bottom

MarginRight(T)

margin-right

OutlineColor(<T as ToAnimatedValue>::AnimatedValue)

outline-color

OutlineStyle(T)

outline-style

OutlineWidth(<T as ToAnimatedValue>::AnimatedValue)

outline-width

OutlineOffset(T)

outline-offset

PaddingTop(<T as ToAnimatedValue>::AnimatedValue)

padding-top

PaddingLeft(<T as ToAnimatedValue>::AnimatedValue)

padding-left

PaddingBottom(<T as ToAnimatedValue>::AnimatedValue)

padding-bottom

PaddingRight(<T as ToAnimatedValue>::AnimatedValue)

padding-right

Cursor(T)

cursor

PointerEvents(T)

pointer-events

Top(T)

top

Left(T)

left

Bottom(T)

bottom

Right(T)

right

ZIndex(T)

z-index

FlexDirection(T)

flex-direction

FlexWrap(T)

flex-wrap

JustifyContent(T)

justify-content

AlignContent(T)

align-content

AlignItems(T)

align-items

FlexGrow(<T as ToAnimatedValue>::AnimatedValue)

flex-grow

FlexShrink(<T as ToAnimatedValue>::AnimatedValue)

flex-shrink

AlignSelf(T)

align-self

Order(T)

order

Width(T)

width

MinWidth(T)

min-width

MaxWidth(T)

max-width

Height(T)

height

MinHeight(T)

min-height

MaxHeight(T)

max-height

BoxSizing(T)

box-sizing

TableLayout(T)

table-layout

TextOverflow(T)

text-overflow

UnicodeBidi(T)

unicode-bidi

TextDecorationLine(T)

text-decoration-line

Methods

impl AnimationValue

pub fn id(&self) -> LonghandId

Returns the longhand id this animated value corresponds to.

pub fn uncompute(&self) -> PropertyDeclaration

"Uncompute" this animation value in order to be used inside the CSS cascade.

pub fn from_declaration(
    decl: &PropertyDeclaration,
    context: &mut Context,
    extra_custom_properties: Option<&Arc<CustomPropertiesMap>>,
    initial: &ComputedValues
) -> Option<Self>

Construct an AnimationValue from a property declaration.

pub fn from_computed_values(
    property: &LonghandId,
    computed_values: &ComputedValues
) -> Option<Self>

Get an AnimationValue for an AnimatableLonghand from a given computed values.

Trait Implementations

impl Clone for AnimationValue

fn clone(&self) -> AnimationValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimationValue

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

Formats the value using the given formatter.

impl PartialEq for AnimationValue

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

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

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

This method tests for !=.

impl MallocSizeOf for AnimationValue

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Animate for AnimationValue

fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()>

Animate a value towards another one, given an animation procedure.

impl ComputeSquaredDistance for AnimationValue

fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()>

Computes the squared distance between two animatable values.

impl ToAnimatedZero for AnimationValue

fn to_animated_zero(&self) -> Result<Self, ()>

Returns a value that, when added with an underlying value, will produce the underlying value. This is used for SMIL animation's "by-animation" where SMIL first interpolates from the zero value to the 'by' value, and then adds the result to the underlying value.