Home | History | Annotate | Download | only in animation 
      1 /*
      2  * Copyright (C) 2000 Lars Knoll (knoll (at) kde.org)
      3  *           (C) 2000 Antti Koivisto (koivisto (at) kde.org)
      4  *           (C) 2000 Dirk Mueller (mueller (at) kde.org)
      5  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
      6  * Copyright (C) 2006 Graham Dennis (graham.dennis (at) gmail.com)
      7  *
      8  * This library is free software; you can redistribute it and/or
      9  * modify it under the terms of the GNU Library General Public
     10  * License as published by the Free Software Foundation; either
     11  * version 2 of the License, or (at your option) any later version.
     12  *
     13  * This library is distributed in the hope that it will be useful,
     14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     16  * Library General Public License for more details.
     17  *
     18  * You should have received a copy of the GNU Library General Public License
     19  * along with this library; see the file COPYING.LIB.  If not, write to
     20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21  * Boston, MA 02110-1301, USA.
     22  *
     23  */
     24 
     25 #ifndef CSSAnimationData_h
     26 #define CSSAnimationData_h
     27 
     28 #include "CSSPropertyNames.h"
     29 #include "core/platform/animation/TimingFunction.h"
     30 #include "core/rendering/style/RenderStyleConstants.h"
     31 #include "wtf/PassRefPtr.h"
     32 #include "wtf/RefCounted.h"
     33 #include "wtf/text/WTFString.h"
     34 
     35 namespace WebCore {
     36 
     37 class CSSAnimationData : public RefCounted<CSSAnimationData> {
     38 public:
     39     ~CSSAnimationData();
     40 
     41     static PassRefPtr<CSSAnimationData> create() { return adoptRef(new CSSAnimationData); }
     42     static PassRefPtr<CSSAnimationData> create(const CSSAnimationData* o) { return adoptRef(new CSSAnimationData(*o)); }
     43 
     44     bool isDelaySet() const { return m_delaySet; }
     45     bool isDirectionSet() const { return m_directionSet; }
     46     bool isDurationSet() const { return m_durationSet; }
     47     bool isFillModeSet() const { return m_fillModeSet; }
     48     bool isIterationCountSet() const { return m_iterationCountSet; }
     49     bool isNameSet() const { return m_nameSet; }
     50     bool isPlayStateSet() const { return m_playStateSet; }
     51     bool isPropertySet() const { return m_propertySet; }
     52     bool isTimingFunctionSet() const { return m_timingFunctionSet; }
     53 
     54     // Flags this to be the special "none" animation (animation-name: none)
     55     bool isNoneAnimation() const { return m_isNone; }
     56     // We can make placeholder CSSAnimationData objects to keep the comma-separated lists
     57     // of properties in sync. isValidAnimation means this is not a placeholder.
     58     bool isValidAnimation() const { return !m_isNone && !m_name.isEmpty(); }
     59 
     60     bool isEmpty() const
     61     {
     62         return (!m_directionSet && !m_durationSet && !m_fillModeSet
     63                 && !m_nameSet && !m_playStateSet && !m_iterationCountSet
     64                 && !m_delaySet && !m_timingFunctionSet && !m_propertySet);
     65     }
     66 
     67     bool isEmptyOrZeroDuration() const
     68     {
     69         return isEmpty() || (m_duration == 0 && m_delay <= 0);
     70     }
     71 
     72     void clearDelay() { m_delaySet = false; }
     73     void clearDirection() { m_directionSet = false; }
     74     void clearDuration() { m_durationSet = false; }
     75     void clearFillMode() { m_fillModeSet = false; }
     76     void clearIterationCount() { m_iterationCountSet = false; }
     77     void clearName() { m_nameSet = false; }
     78     void clearPlayState() { m_playStateSet = AnimPlayStatePlaying; }
     79     void clearProperty() { m_propertySet = false; }
     80     void clearTimingFunction() { m_timingFunctionSet = false; }
     81 
     82     void clearAll()
     83     {
     84         clearDelay();
     85         clearDirection();
     86         clearDuration();
     87         clearFillMode();
     88         clearIterationCount();
     89         clearName();
     90         clearPlayState();
     91         clearProperty();
     92         clearTimingFunction();
     93     }
     94 
     95     double delay() const { return m_delay; }
     96 
     97     enum AnimationMode {
     98         AnimateAll,
     99         AnimateNone,
    100         AnimateSingleProperty
    101     };
    102 
    103     enum AnimationDirection {
    104         AnimationDirectionNormal,
    105         AnimationDirectionAlternate,
    106         AnimationDirectionReverse,
    107         AnimationDirectionAlternateReverse
    108     };
    109     AnimationDirection direction() const { return static_cast<AnimationDirection>(m_direction); }
    110     bool directionIsForwards() const { return m_direction == AnimationDirectionNormal || m_direction == AnimationDirectionAlternate; }
    111 
    112     unsigned fillMode() const { return m_fillMode; }
    113 
    114     double duration() const { return m_duration; }
    115 
    116     enum { IterationCountInfinite = -1 };
    117     double iterationCount() const { return m_iterationCount; }
    118     const AtomicString& name() const { return m_name; }
    119     EAnimPlayState playState() const { return static_cast<EAnimPlayState>(m_playState); }
    120     CSSPropertyID property() const { return m_property; }
    121     TimingFunction* timingFunction() const { return m_timingFunction.get(); }
    122     AnimationMode animationMode() const { return m_mode; }
    123 
    124     void setDelay(double c) { m_delay = c; m_delaySet = true; }
    125     void setDirection(AnimationDirection d) { m_direction = d; m_directionSet = true; }
    126     void setDuration(double d) { ASSERT(d >= 0); m_duration = d; m_durationSet = true; }
    127     void setFillMode(unsigned f) { m_fillMode = f; m_fillModeSet = true; }
    128     void setIterationCount(double c) { m_iterationCount = c; m_iterationCountSet = true; }
    129     void setName(const AtomicString& n) { m_name = n; m_nameSet = true; }
    130     void setPlayState(EAnimPlayState d) { m_playState = d; m_playStateSet = true; }
    131     void setProperty(CSSPropertyID t) { m_property = t; m_propertySet = true; }
    132     void setTimingFunction(PassRefPtr<TimingFunction> f) { m_timingFunction = f; m_timingFunctionSet = true; }
    133     void setAnimationMode(AnimationMode mode) { m_mode = mode; }
    134 
    135     void setIsNoneAnimation(bool n) { m_isNone = n; }
    136 
    137     CSSAnimationData& operator=(const CSSAnimationData& o);
    138 
    139     // return true every CSSAnimationData in the chain (defined by m_next) match
    140     bool operator==(const CSSAnimationData& o) const { return animationsMatchForStyleRecalc(&o); }
    141     bool operator!=(const CSSAnimationData& o) const { return !(*this == o); }
    142 
    143     bool fillsBackwards() const { return m_fillModeSet && (m_fillMode == AnimationFillModeBackwards || m_fillMode == AnimationFillModeBoth); }
    144     bool fillsForwards() const { return m_fillModeSet && (m_fillMode == AnimationFillModeForwards || m_fillMode == AnimationFillModeBoth); }
    145 
    146 private:
    147     CSSAnimationData();
    148     explicit CSSAnimationData(const CSSAnimationData&);
    149 
    150     // Return whether this object matches another CSSAnimationData object for
    151     // the purposes of style recalc. This excludes some properties.
    152     bool animationsMatchForStyleRecalc(const CSSAnimationData*) const;
    153 
    154     AtomicString m_name;
    155     CSSPropertyID m_property;
    156     AnimationMode m_mode;
    157     double m_iterationCount;
    158     double m_delay;
    159     double m_duration;
    160     RefPtr<TimingFunction> m_timingFunction;
    161     unsigned m_direction : 2; // AnimationDirection
    162     unsigned m_fillMode : 2;
    163 
    164     unsigned m_playState     : 2;
    165 
    166     bool m_delaySet          : 1;
    167     bool m_directionSet      : 1;
    168     bool m_durationSet       : 1;
    169     bool m_fillModeSet       : 1;
    170     bool m_iterationCountSet : 1;
    171     bool m_nameSet           : 1;
    172     bool m_playStateSet      : 1;
    173     bool m_propertySet       : 1;
    174     bool m_timingFunctionSet : 1;
    175 
    176     bool m_isNone            : 1;
    177 
    178 public:
    179     static double initialAnimationDelay() { return 0; }
    180     static AnimationDirection initialAnimationDirection() { return AnimationDirectionNormal; }
    181     static double initialAnimationDuration() { return 0; }
    182     static unsigned initialAnimationFillMode() { return AnimationFillModeNone; }
    183     static double initialAnimationIterationCount() { return 1.0; }
    184     static const AtomicString& initialAnimationName();
    185     static EAnimPlayState initialAnimationPlayState() { return AnimPlayStatePlaying; }
    186     static CSSPropertyID initialAnimationProperty() { return CSSPropertyInvalid; }
    187     static const PassRefPtr<TimingFunction> initialAnimationTimingFunction() { return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); }
    188 };
    189 
    190 } // namespace WebCore
    191 
    192 #endif // CSSAnimationData_h
    193