Changeset 35568

Timestamp:

08/05/08 12:08:45 (4 months ago)

Author:

dino@apple.com

Message:

Reviewed by Dave Hyatt

Add support for CSS Animation properties to RenderStyle
https://bugs.webkit.org/show_bug.cgi?id=20068

(also fix some minor whitespace issues and remove debugging code)

* css/CSSComputedStyleDeclaration.cpp:
* css/CSSStyleSelector.cpp:
* page/AnimationController.cpp:
* rendering/style/RenderStyle.cpp:
* rendering/style/RenderStyle.h:

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSComputedStyleDeclaration.cpp (modified) (3 diffs)
• css/CSSStyleSelector.cpp (modified) (5 diffs)
• page/AnimationController.cpp (modified) (7 diffs)
• rendering/style/RenderStyle.cpp (modified) (11 diffs)
• rendering/style/RenderStyle.h (modified) (12 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-08-05  Dean Jackson  <dino@apple.com>
+
+        Reviewed by Dave Hyatt
+
+        Add support for CSS Animation properties to RenderStyle
+        https://bugs.webkit.org/show_bug.cgi?id=20068
+
+        (also fix some minor whitespace issues and remove debugging code)
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        * css/CSSStyleSelector.cpp:
+        * page/AnimationController.cpp:
+        * rendering/style/RenderStyle.cpp:
+        * rendering/style/RenderStyle.h:
+
 2008-08-05  Kevin McCullough  <kmccullough@apple.com>
 

trunk/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1069 +1069 @@
             }
             else
-                list->append(CSSPrimitiveValue::create(RenderStyle::initialDelay(), CSSPrimitiveValue::CSS_S));
+                list->append(CSSPrimitiveValue::create(RenderStyle::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
             return list.release();
         }
@@ -1080 +1080 @@
             }
             else
-                list->append(CSSPrimitiveValue::create(RenderStyle::initialDuration(), CSSPrimitiveValue::CSS_S));
+                list->append(CSSPrimitiveValue::create(RenderStyle::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
             return list.release();
         }
@@ -1093 +1093 @@
             }
             else {
-                const TimingFunction& tf = RenderStyle::initialTimingFunction();
+                const TimingFunction& tf = RenderStyle::initialAnimationTimingFunction();
                 list->append(CSSTimingFunctionValue::create(tf.x1(), tf.y1(), tf.x2(), tf.y2()));
             }

trunk/WebCore/css/CSSStyleSelector.cpp

@@ -200 +200 @@
 if (isInitial) { \
     AnimationList* list = m_style->accessTransitions(); \
-    (*list)[0]->set##Prop(RenderStyle::initial##Prop()); \
+    (*list)[0]->set##Prop(RenderStyle::initialAnimation##Prop()); \
     for (size_t i = 1; i < list->size(); ++i) \
         (*list)[0]->clear##Prop(); \
@@ -5005 +5005 @@
 {
     if (value->cssValueType() == CSSValue::CSS_INITIAL) {
-        transition->setDuration(RenderStyle::initialDuration());
+        transition->setDuration(RenderStyle::initialAnimationDuration());
         return;
     }
@@ -5022 +5022 @@
 {
     if (value->cssValueType() == CSSValue::CSS_INITIAL) {
-        transition->setDelay(RenderStyle::initialDelay());
+        transition->setDelay(RenderStyle::initialAnimationDelay());
         return;
     }
@@ -5040 +5040 @@
 {
     if (value->cssValueType() == CSSValue::CSS_INITIAL) {
-        transition->setTimingFunction(RenderStyle::initialTimingFunction());
+        transition->setTimingFunction(RenderStyle::initialAnimationTimingFunction());
         return;
     }
@@ -5075 +5075 @@
 {
     if (value->cssValueType() == CSSValue::CSS_INITIAL) {
-        transition->setProperty(RenderStyle::initialProperty());
+        transition->setProperty(RenderStyle::initialAnimationProperty());
         return;
     }

trunk/WebCore/page/AnimationController.cpp

@@ -112 +112 @@
     }
     
-    void startTimer(Element* element, const AtomicString& name, int property, bool reset, 
+    void startTimer(Element* element, const AtomicString& name, int property, bool reset,
                     const AtomicString& eventType, double elapsedTime)
     {
@@ -192 +192 @@
     void suspendAnimations();
     void resumeAnimations();
-    bool suspended() const      { return m_suspended; }
+    bool suspended() const { return m_suspended; }
     
     void overrideImplicitAnimations(int property);
@@ -216 +216 @@
 class AnimationBase : public Noncopyable {
 public:
-    AnimationBase(const Animation* transition, RenderObject* renderer, CompositeAnimation* compAnim);    
+    AnimationBase(const Animation* transition, RenderObject* renderer, CompositeAnimation* compAnim);
     virtual ~AnimationBase()
     {
@@ -309 +309 @@
     
     void animationTimerCallbackFired(const AtomicString& eventType, double elapsedTime);
-    void animationEventDispatcherFired(Element* element, const AtomicString& name, int property, bool reset, 
+    void animationEventDispatcherFired(Element* element, const AtomicString& name, int property, bool reset,
                                        const AtomicString& eventType, double elapsedTime);
     
@@ -699 +699 @@
 }
 
-void AnimationBase::animationEventDispatcherFired(Element* element, const AtomicString& name, int property, 
+void AnimationBase::animationEventDispatcherFired(Element* element, const AtomicString& name, int property,
                                                   bool reset, const AtomicString& eventType, double elapsedTime)
 {
@@ -1741 +1741 @@
 void AnimationController::suspendAnimations(Document* document)
 {
-#ifdef DEBUG_STATE_MACHINE
-    fprintf(stderr, "AnimationController %p suspendAnimations for document %p\n", this, document);
-#endif
     m_data->suspendAnimations(document);
 }
@@ -1749 +1746 @@
 void AnimationController::resumeAnimations(Document* document)
 {
-#ifdef DEBUG_STATE_MACHINE
-    fprintf(stderr, "AnimationController %p resumeAnimations for document %p\n", this, document);
-#endif
     m_data->resumeAnimations(document);
 }

trunk/WebCore/rendering/style/RenderStyle.cpp

@@ -665 +665 @@
 }
 
+bool KeyframeList::operator==(const KeyframeList& o) const
+{
+    if (m_keyframes.size() != o.m_keyframes.size())
+        return false;
+
+    Vector<KeyframeValue>::const_iterator it2 = o.m_keyframes.begin();
+    for (Vector<KeyframeValue>::const_iterator it1 = m_keyframes.begin(); it1 != m_keyframes.end(); ++it1) {
+        if (it1->key != it2->key)
+            return false;
+        const RenderStyle& style1 = it1->style;
+        const RenderStyle& style2 = it2->style;
+        if (!(style1 == style2))
+            return false;
+        ++it2;
+    }
+
+    return true;
+}
+
+void
+KeyframeList::insert(float inKey, const RenderStyle& inStyle)
+{
+    if (inKey < 0 || inKey > 1)
+        return;
+
+    for (size_t i = 0; i < m_keyframes.size(); ++i) {
+        if (m_keyframes[i].key == inKey) {
+            m_keyframes[i].style = inStyle;
+            return;
+        }
+        if (m_keyframes[i].key > inKey) {
+            // insert before
+            m_keyframes.insert(i, KeyframeValue());
+            m_keyframes[i].key = inKey;
+            m_keyframes[i].style = inStyle;
+            return;
+        }
+    }
+    
+    // append
+    m_keyframes.append(KeyframeValue());
+    m_keyframes[m_keyframes.size()-1].key = inKey;
+    m_keyframes[m_keyframes.size()-1].style = inStyle;
+}
+
 Animation::Animation()
-    : m_duration(RenderStyle::initialDuration())
-    , m_timingFunction(RenderStyle::initialTimingFunction())
-    , m_delay(RenderStyle::initialDelay())
-    , m_property(RenderStyle::initialProperty())
+    : m_delay(RenderStyle::initialAnimationDelay())
+    , m_direction(RenderStyle::initialAnimationDirection())
+    , m_duration(RenderStyle::initialAnimationDuration())
+    , m_iterationCount(RenderStyle::initialAnimationIterationCount())
+    , m_name(RenderStyle::initialAnimationName())
+    , m_property(RenderStyle::initialAnimationProperty())
+    , m_timingFunction(RenderStyle::initialAnimationTimingFunction())
+    , m_playState(RenderStyle::initialAnimationPlayState())
+    , m_delaySet(false)
+    , m_directionSet(false)
     , m_durationSet(false)
+    , m_iterationCountSet(false)
+    , m_nameSet(false)
+    , m_playStateSet(false)
+    , m_propertySet(false)
     , m_timingFunctionSet(false)
-    , m_delaySet(false)
-    , m_propertySet(false)
+    , m_isNone(false)
 {
 }
@@ -679 +733 @@
 Animation::Animation(const Animation& o)
     : RefCounted<Animation>()
+    , m_delay(o.m_delay)
+    , m_direction(o.m_direction)
     , m_duration(o.m_duration)
+    , m_iterationCount(o.m_iterationCount)
+    , m_name(o.m_name)
+    , m_property(o.m_property)
     , m_timingFunction(o.m_timingFunction)
-    , m_delay(o.m_delay)
-    , m_property(o.m_property)
+    , m_playState(o.m_playState)
+    , m_delaySet(o.m_delaySet)
+    , m_directionSet(o.m_directionSet)
     , m_durationSet(o.m_durationSet)
+    , m_iterationCountSet(o.m_iterationCountSet)
+    , m_nameSet(o.m_nameSet)
+    , m_playStateSet(o.m_playStateSet)
+    , m_propertySet(o.m_propertySet)
     , m_timingFunctionSet(o.m_timingFunctionSet)
-    , m_delaySet(o.m_delaySet)
-    , m_propertySet(o.m_propertySet)
+    , m_isNone(o.m_isNone)
 {
 }
@@ -693 +756 @@
 {
     m_delay = o.m_delay;
+    m_direction = o.m_direction;
     m_duration = o.m_duration;
+    m_iterationCount = o.m_iterationCount;
+    m_name = o.m_name;
+    m_playState = o.m_playState;
+    m_property = o.m_property;
     m_timingFunction = o.m_timingFunction;
-    m_property = o.m_property;
 
     m_delaySet = o.m_delaySet;
+    m_directionSet = o.m_directionSet;
     m_durationSet = o.m_durationSet;
+    m_iterationCountSet = o.m_iterationCountSet;
+    m_nameSet = o.m_nameSet;
+    m_playStateSet = o.m_playStateSet;
+    m_propertySet = o.m_propertySet;
     m_timingFunctionSet = o.m_timingFunctionSet;
-    m_propertySet = o.m_propertySet;
+
+    m_isNone = o.m_isNone;
 
     return *this;
 }
 
-bool Animation::animationsMatch(const Animation* o) const
+bool Animation::animationsMatch(const Animation* o, bool matchPlayStates /* = true */) const
 {
     if (!o)
         return false;
     
-    bool result = m_duration == o->m_duration &&
+    bool result = m_delay == o->m_delay &&
+                  m_direction == o->m_direction &&
+                  m_duration == o->m_duration &&
+                  m_iterationCount == o->m_iterationCount &&
+                  m_name == o->m_name &&
+                  m_property == o->m_property && 
                   m_timingFunction == o->m_timingFunction &&
-                  m_delay == o->m_delay &&
-                  m_property == o->m_property && 
-                  m_durationSet == o->m_durationSet && 
-                  m_timingFunctionSet == o->m_timingFunctionSet && 
                   m_delaySet == o->m_delaySet &&
-                  m_propertySet == o->m_propertySet;
-    
-    return result;
+                  m_directionSet == o->m_directionSet &&
+                  m_durationSet == o->m_durationSet &&
+                  m_iterationCountSet == o->m_iterationCountSet &&
+                  m_nameSet == o->m_nameSet &&
+                  m_propertySet == o->m_propertySet &&
+                  m_timingFunctionSet == o->m_timingFunctionSet &&
+                  m_isNone == o->m_isNone;
+
+    if (!result)
+        return false;
+
+    if (matchPlayStates && (m_playState != o->m_playState || m_playStateSet != o->m_playStateSet))
+        return false;
+
+    // now check keyframes
+    if ((m_keyframeList.get() && !o->m_keyframeList.get()) || (!m_keyframeList.get() && o->m_keyframeList.get()))
+        return false;
+    if (!(m_keyframeList.get()))
+        return true;
+    return *m_keyframeList == *o->m_keyframeList;
 }
 
@@ -733 +824 @@
     size_t i;
     FILL_UNSET_PROPERTY(isDelaySet, delay, setDelay);
+    FILL_UNSET_PROPERTY(isDirectionSet, direction, setDirection);
     FILL_UNSET_PROPERTY(isDurationSet, duration, setDuration);
+    FILL_UNSET_PROPERTY(isIterationCountSet, iterationCount, setIterationCount);
+    FILL_UNSET_PROPERTY(isPlayStateSet, playState, setPlayState);
+    FILL_UNSET_PROPERTY(isNameSet, name, setName);
     FILL_UNSET_PROPERTY(isTimingFunctionSet, timingFunction, setTimingFunction);
     FILL_UNSET_PROPERTY(isPropertySet, property, setProperty);
@@ -761 +856 @@
     , m_borderFit(RenderStyle::initialBorderFit())
     , m_boxShadow(0)
+    , m_animations(0)
     , m_transitions(0)
     , m_mask(FillLayer(MaskFillLayer))
@@ -788 +884 @@
     , m_boxShadow(o.m_boxShadow ? new ShadowData(*o.m_boxShadow) : 0)
     , m_boxReflect(o.m_boxReflect)
+    , m_animations(o.m_animations ? new AnimationList(*o.m_animations) : 0)
     , m_transitions(o.m_transitions ? new AnimationList(*o.m_transitions) : 0)
     , m_mask(o.m_mask)
@@ -841 +938 @@
         && shadowDataEquivalent(o)
         && reflectionDataEquivalent(o)
+        && animationDataEquivalent(o)
         && transitionDataEquivalent(o)
         && m_mask == o.m_mask
@@ -868 +966 @@
     return true;
 
+}
+
+void StyleRareNonInheritedData::updateKeyframes(const CSSStyleSelector* styleSelector)
+{
+    if (m_animations) {
+        for (size_t i = 0; i < m_animations->size(); ++i) {
+            if ((*m_animations)[i]->isValidAnimation()) {
+                // When keyframes have been parsed, execute this code.
+                // RefPtr<KeyframeList> keyframe = styleSelector->findKeyframeRule((*m_animations)[i]->name());
+                // (*m_animations)[i]->setAnimationKeyframe(keyframe);
+            }
+        }
+    }
+}
+
+bool StyleRareNonInheritedData::animationDataEquivalent(const StyleRareNonInheritedData& o) const
+{
+    if (!m_animations && o.m_animations || m_animations && !o.m_animations)
+        return false;
+    if (m_animations && o.m_animations && (*m_animations != *o.m_animations))
+        return false;
+    return true;
 }
 
@@ -1844 +1964 @@
 #endif
 
+void RenderStyle::adjustAnimations()
+{
+    AnimationList* animationList = rareNonInheritedData->m_animations;
+    if (!animationList)
+        return;
+
+    if (animationList->size() == 0) {
+        clearAnimations();
+        return;
+    }
+
+    // get rid of empty transitions and anything beyond them
+    for (size_t i = 0; i < animationList->size(); ++i) {
+        if ((*animationList)[i]->isEmpty()) {
+            animationList->resize(i);
+            break;
+        }
+    }
+    
+    if (animationList->size() == 0) {
+        clearAnimations();
+        return;
+    }
+    
+    // Repeat patterns into layers that don't have some properties set.
+    animationList->fillUnsetProperties();
+}
+
 void RenderStyle::adjustTransitions()
 {
@@ -1884 +2032 @@
 }
 
+AnimationList* RenderStyle::accessAnimations()
+{
+    AnimationList* list = rareNonInheritedData.access()->m_animations;
+    if (!list)
+        rareNonInheritedData.access()->m_animations = new AnimationList();
+    return rareNonInheritedData->m_animations;
+}
+
 AnimationList* RenderStyle::accessTransitions()
 {
@@ -1892 +2048 @@
 }
 
-}
+const Animation* RenderStyle::transitionForProperty(int property)
+{
+    if (transitions()) {
+        for (size_t i = 0; i < transitions()->size(); ++i) {
+            const Animation* p = (*transitions())[i].get();
+            if (p->property() == cAnimateAll || p->property() == property) {
+                return p;
+            }
+        }
+    }
+    return 0;
+}
+
+}

trunk/WebCore/rendering/style/RenderStyle.h

@@ -73 +73 @@
 class CachedResource;
 class CursorList;
+class KeyframeList;
 class Pair;
 class RenderArena;
@@ -1258 +1259 @@
 };
 
+enum EAnimPlayState {
+    AnimPlayStatePlaying = 0x0,
+    AnimPlayStatePaused = 0x1
+};
+
 class Animation : public RefCounted<Animation> {
 public:
@@ -1264 +1270 @@
     
     bool isDelaySet() const { return m_delaySet; }
+    bool isDirectionSet() const { return m_directionSet; }
     bool isDurationSet() const { return m_durationSet; }
+    bool isIterationCountSet() const { return m_iterationCountSet; }
+    bool isNameSet() const { return m_nameSet; }
+    bool isPlayStateSet() const { return m_playStateSet; }
+    bool isPropertySet() const { return m_propertySet; }
     bool isTimingFunctionSet() const { return m_timingFunctionSet; }
-    bool isPropertySet() const { return m_propertySet; }
+
+    // Flags this to be the special "none" animation (animation-name: none)
+    bool isNoneAnimation() const { return m_isNone; }
+    // We can make placeholder Animation objects to keep the comma-separated lists
+    // of properties in sync. isValidAnimation means this is not a placeholder.
+    bool isValidAnimation() const { return !m_isNone && !m_name.isEmpty(); }
 
     bool isEmpty() const
     {
-        return (!m_durationSet && !m_delaySet && !m_timingFunctionSet && !m_propertySet);
+        return (!m_directionSet && !m_durationSet && !m_nameSet && !m_playStateSet && 
+               !m_iterationCountSet && !m_delaySet && !m_timingFunctionSet && !m_propertySet);
     }
 
@@ -1279 +1296 @@
 
     void clearDelay() { m_delaySet = false; }
+    void clearDirection() { m_directionSet = false; }
     void clearDuration() { m_durationSet = false; }
+    void clearIterationCount() { m_iterationCountSet = false; }
+    void clearName() { m_nameSet = false; }
+    void clearPlayState() { m_playStateSet = AnimPlayStatePlaying; }
+    void clearProperty() { m_propertySet = false; }
     void clearTimingFunction() { m_timingFunctionSet = false; }
 
-    void clearProperty() { m_propertySet = false; }
-
     double delay() const { return m_delay; }
+    bool direction() const { return m_direction; }
     double duration() const { return m_duration; }
+    int iterationCount() const { return m_iterationCount; }
+    const String& name() const { return m_name; }
+    unsigned playState() const { return m_playState; }
+    int property() const { return m_property; }
     const TimingFunction& timingFunction() const { return m_timingFunction; }
-    int property() const { return m_property; }
+
+    const RefPtr<KeyframeList>& keyframeList() const { return m_keyframeList; }
 
     void setDelay(double c) { m_delay = c; m_delaySet = true; }
+    void setDirection(bool d) { m_direction = d; m_directionSet = true; }
     void setDuration(double d) { ASSERT(d >= 0); m_duration = d; m_durationSet = true; }
+    void setIterationCount(int c) { m_iterationCount = c; m_iterationCountSet = true; }
+    void setName(const String& n) { m_name = n; m_nameSet = true; }
+    void setPlayState(unsigned d) { m_playState = d; m_playStateSet = true; }
+    void setProperty(int t) { m_property = t; m_propertySet = true; }
     void setTimingFunction(const TimingFunction& f) { m_timingFunction = f; m_timingFunctionSet = true; }
-    void setProperty(int t) { m_property = t; m_propertySet = true; }
+
+    void setIsNoneAnimation(bool n) { m_isNone = n; }
+
+    void setAnimationKeyframe(const RefPtr<KeyframeList> keyframe)  { m_keyframeList = keyframe; }
 
     Animation& operator=(const Animation& o);
 
     // return true if all members of this class match (excluding m_next)
-    bool animationsMatch(const Animation* t) const;
+    bool animationsMatch(const Animation* t, bool matchPlayStates=true) const;
 
     // return true every Animation in the chain (defined by m_next) match 
@@ -1307 +1341 @@
     Animation(const Animation& o);
     
+    double m_delay;
+    bool m_direction;
     double m_duration;
+    int m_iterationCount;
+    String m_name;
+    int m_property;
     TimingFunction m_timingFunction;
-    double m_delay;
-    int m_property;
-
+
+    RefPtr<KeyframeList> m_keyframeList;
+
+    unsigned m_playState     : 2;
+
+    bool m_delaySet          : 1;
+    bool m_directionSet      : 1;
     bool m_durationSet       : 1;
+    bool m_iterationCountSet : 1;
+    bool m_nameSet           : 1;
+    bool m_playStateSet      : 1;
+    bool m_propertySet       : 1;
     bool m_timingFunctionSet : 1;
-    bool m_delaySet          : 1;
-    bool m_propertySet       : 1;
+    
+    bool m_isNone            : 1;
 };
 
@@ -1377 +1424 @@
     bool shadowDataEquivalent(const StyleRareNonInheritedData& o) const;
     bool reflectionDataEquivalent(const StyleRareNonInheritedData& o) const;
+    bool animationDataEquivalent(const StyleRareNonInheritedData&) const;
     bool transitionDataEquivalent(const StyleRareNonInheritedData&) const;
+    void updateKeyframes(const CSSStyleSelector* styleSelector);
 
     int lineClamp; // An Apple extension.
@@ -1404 +1453 @@
     RefPtr<StyleReflection> m_boxReflect;
 
+    AnimationList* m_animations;
     AnimationList* m_transitions;
 
@@ -2102 +2152 @@
 
     // Apple-specific property getter methods
+    const AnimationList* animations() const { return rareNonInheritedData->m_animations; }
+    const AnimationList* transitions() const { return rareNonInheritedData->m_transitions; }
+
+    AnimationList* accessAnimations();
     AnimationList* accessTransitions();
-    const AnimationList* transitions() const { return rareNonInheritedData->m_transitions; }
+
+    bool hasAnimations() const { return rareNonInheritedData->m_animations && rareNonInheritedData->m_animations->size() > 0; }
     bool hasTransitions() const { return rareNonInheritedData->m_transitions && rareNonInheritedData->m_transitions->size() > 0; }
+
+    // return the first found Animation (including 'all' transitions)
+    const Animation* transitionForProperty(int property);
 
     int lineClamp() const { return rareNonInheritedData->lineClamp; }
@@ -2369 +2427 @@
 
     // Apple-specific property setters
+    void clearAnimations()
+    {
+        if (rareNonInheritedData.access()->m_animations) {
+            delete rareNonInheritedData.access()->m_animations;
+            rareNonInheritedData.access()->m_animations = 0;
+        }
+    }
     void clearTransitions()
     {
@@ -2377 +2442 @@
     }
 
+    void inheritAnimations(const AnimationList* parent) { clearAnimations(); if (parent) rareNonInheritedData.access()->m_animations = new AnimationList(*parent); }
     void inheritTransitions(const AnimationList* parent) { clearTransitions(); if (parent) rareNonInheritedData.access()->m_transitions = new AnimationList(*parent); }
+    void adjustAnimations();
     void adjustTransitions();
+    void updateKeyframes(const CSSStyleSelector* styleSelector) { if (rareNonInheritedData.get()) rareNonInheritedData.access()->updateKeyframes(styleSelector); }