1 /* 2 * Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of 14 * its contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include "config.h" 30 #include "AnimationBase.h" 31 32 #include "AnimationControllerPrivate.h" 33 #include "CSSMutableStyleDeclaration.h" 34 #include "CSSPropertyLonghand.h" 35 #include "CSSPropertyNames.h" 36 #include "CompositeAnimation.h" 37 #include "Document.h" 38 #include "EventNames.h" 39 #include "FloatConversion.h" 40 #include "Frame.h" 41 #include "IdentityTransformOperation.h" 42 #include "ImplicitAnimation.h" 43 #include "KeyframeAnimation.h" 44 #include "MatrixTransformOperation.h" 45 #include "Matrix3DTransformOperation.h" 46 #include "RenderBox.h" 47 #include "RenderLayer.h" 48 #include "RenderLayerBacking.h" 49 #include "RenderStyle.h" 50 #include "UnitBezier.h" 51 #include <algorithm> 52 #include <wtf/CurrentTime.h> 53 54 using namespace std; 55 56 namespace WebCore { 57 58 // The epsilon value we pass to UnitBezier::solve given that the animation is going to run over |dur| seconds. The longer the 59 // animation, the more precision we need in the timing function result to avoid ugly discontinuities. 60 static inline double solveEpsilon(double duration) 61 { 62 return 1.0 / (200.0 * duration); 63 } 64 65 static inline double solveCubicBezierFunction(double p1x, double p1y, double p2x, double p2y, double t, double duration) 66 { 67 // Convert from input time to parametric value in curve, then from 68 // that to output time. 69 UnitBezier bezier(p1x, p1y, p2x, p2y); 70 return bezier.solve(t, solveEpsilon(duration)); 71 } 72 73 static inline double solveStepsFunction(int numSteps, bool stepAtStart, double t) 74 { 75 if (stepAtStart) 76 return min(1.0, (floor(numSteps * t) + 1) / numSteps); 77 return floor(numSteps * t) / numSteps; 78 } 79 80 static inline int blendFunc(const AnimationBase*, int from, int to, double progress) 81 { 82 return int(from + (to - from) * progress); 83 } 84 85 static inline double blendFunc(const AnimationBase*, double from, double to, double progress) 86 { 87 return from + (to - from) * progress; 88 } 89 90 static inline float blendFunc(const AnimationBase*, float from, float to, double progress) 91 { 92 return narrowPrecisionToFloat(from + (to - from) * progress); 93 } 94 95 static inline Color blendFunc(const AnimationBase* anim, const Color& from, const Color& to, double progress) 96 { 97 // We need to preserve the state of the valid flag at the end of the animation 98 if (progress == 1 && !to.isValid()) 99 return Color(); 100 101 // Contrary to the name, RGBA32 actually stores ARGB, so we can initialize Color directly from premultipliedARGBFromColor(). 102 // Also, premultipliedARGBFromColor() bails on zero alpha, so special-case that. 103 Color premultFrom = from.alpha() ? premultipliedARGBFromColor(from) : 0; 104 Color premultTo = to.alpha() ? premultipliedARGBFromColor(to) : 0; 105 106 Color premultBlended(blendFunc(anim, premultFrom.red(), premultTo.red(), progress), 107 blendFunc(anim, premultFrom.green(), premultTo.green(), progress), 108 blendFunc(anim, premultFrom.blue(), premultTo.blue(), progress), 109 blendFunc(anim, premultFrom.alpha(), premultTo.alpha(), progress)); 110 111 return Color(colorFromPremultipliedARGB(premultBlended.rgb())); 112 } 113 114 static inline Length blendFunc(const AnimationBase*, const Length& from, const Length& to, double progress) 115 { 116 return to.blend(from, narrowPrecisionToFloat(progress)); 117 } 118 119 static inline LengthSize blendFunc(const AnimationBase* anim, const LengthSize& from, const LengthSize& to, double progress) 120 { 121 return LengthSize(blendFunc(anim, from.width(), to.width(), progress), 122 blendFunc(anim, from.height(), to.height(), progress)); 123 } 124 125 static inline IntSize blendFunc(const AnimationBase* anim, const IntSize& from, const IntSize& to, double progress) 126 { 127 return IntSize(blendFunc(anim, from.width(), to.width(), progress), 128 blendFunc(anim, from.height(), to.height(), progress)); 129 } 130 131 static inline ShadowStyle blendFunc(const AnimationBase* anim, ShadowStyle from, ShadowStyle to, double progress) 132 { 133 if (from == to) 134 return to; 135 136 double fromVal = from == Normal ? 1 : 0; 137 double toVal = to == Normal ? 1 : 0; 138 double result = blendFunc(anim, fromVal, toVal, progress); 139 return result > 0 ? Normal : Inset; 140 } 141 142 static inline ShadowData* blendFunc(const AnimationBase* anim, const ShadowData* from, const ShadowData* to, double progress) 143 { 144 ASSERT(from && to); 145 if (from->style() != to->style()) 146 return new ShadowData(*to); 147 148 return new ShadowData(blendFunc(anim, from->x(), to->x(), progress), 149 blendFunc(anim, from->y(), to->y(), progress), 150 blendFunc(anim, from->blur(), to->blur(), progress), 151 blendFunc(anim, from->spread(), to->spread(), progress), 152 blendFunc(anim, from->style(), to->style(), progress), 153 from->isWebkitBoxShadow(), 154 blendFunc(anim, from->color(), to->color(), progress)); 155 } 156 157 static inline TransformOperations blendFunc(const AnimationBase* anim, const TransformOperations& from, const TransformOperations& to, double progress) 158 { 159 TransformOperations result; 160 161 // If we have a transform function list, use that to do a per-function animation. Otherwise do a Matrix animation 162 if (anim->isTransformFunctionListValid()) { 163 unsigned fromSize = from.operations().size(); 164 unsigned toSize = to.operations().size(); 165 unsigned size = max(fromSize, toSize); 166 for (unsigned i = 0; i < size; i++) { 167 RefPtr<TransformOperation> fromOp = (i < fromSize) ? from.operations()[i].get() : 0; 168 RefPtr<TransformOperation> toOp = (i < toSize) ? to.operations()[i].get() : 0; 169 RefPtr<TransformOperation> blendedOp = toOp ? toOp->blend(fromOp.get(), progress) : (fromOp ? fromOp->blend(0, progress, true) : 0); 170 if (blendedOp) 171 result.operations().append(blendedOp); 172 else { 173 RefPtr<TransformOperation> identityOp = IdentityTransformOperation::create(); 174 if (progress > 0.5) 175 result.operations().append(toOp ? toOp : identityOp); 176 else 177 result.operations().append(fromOp ? fromOp : identityOp); 178 } 179 } 180 } else { 181 // Convert the TransformOperations into matrices 182 IntSize size = anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : IntSize(); 183 TransformationMatrix fromT; 184 TransformationMatrix toT; 185 from.apply(size, fromT); 186 to.apply(size, toT); 187 188 toT.blend(fromT, progress); 189 190 // Append the result 191 result.operations().append(Matrix3DTransformOperation::create(toT)); 192 } 193 return result; 194 } 195 196 static inline EVisibility blendFunc(const AnimationBase* anim, EVisibility from, EVisibility to, double progress) 197 { 198 // Any non-zero result means we consider the object to be visible. Only at 0 do we consider the object to be 199 // invisible. The invisible value we use (HIDDEN vs. COLLAPSE) depends on the specified from/to values. 200 double fromVal = from == VISIBLE ? 1. : 0.; 201 double toVal = to == VISIBLE ? 1. : 0.; 202 if (fromVal == toVal) 203 return to; 204 double result = blendFunc(anim, fromVal, toVal, progress); 205 return result > 0. ? VISIBLE : (to != VISIBLE ? to : from); 206 } 207 208 static inline LengthBox blendFunc(const AnimationBase* anim, const LengthBox& from, const LengthBox& to, double progress) 209 { 210 // Length types have to match to animate 211 if (from.top().type() != to.top().type() 212 || from.right().type() != to.right().type() 213 || from.bottom().type() != to.bottom().type() 214 || from.left().type() != to.left().type()) 215 return to; 216 217 LengthBox result(blendFunc(anim, from.top(), to.top(), progress), 218 blendFunc(anim, from.right(), to.right(), progress), 219 blendFunc(anim, from.bottom(), to.bottom(), progress), 220 blendFunc(anim, from.left(), to.left(), progress)); 221 return result; 222 } 223 224 class PropertyWrapperBase; 225 226 static void addShorthandProperties(); 227 static PropertyWrapperBase* wrapperForProperty(int propertyID); 228 229 class PropertyWrapperBase { 230 WTF_MAKE_NONCOPYABLE(PropertyWrapperBase); WTF_MAKE_FAST_ALLOCATED; 231 public: 232 PropertyWrapperBase(int prop) 233 : m_prop(prop) 234 { 235 } 236 237 virtual ~PropertyWrapperBase() { } 238 239 virtual bool isShorthandWrapper() const { return false; } 240 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const = 0; 241 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const = 0; 242 243 int property() const { return m_prop; } 244 245 #if USE(ACCELERATED_COMPOSITING) 246 virtual bool animationIsAccelerated() const { return false; } 247 #endif 248 249 private: 250 int m_prop; 251 }; 252 253 template <typename T> 254 class PropertyWrapperGetter : public PropertyWrapperBase { 255 public: 256 PropertyWrapperGetter(int prop, T (RenderStyle::*getter)() const) 257 : PropertyWrapperBase(prop) 258 , m_getter(getter) 259 { 260 } 261 262 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const 263 { 264 // If the style pointers are the same, don't bother doing the test. 265 // If either is null, return false. If both are null, return true. 266 if ((!a && !b) || a == b) 267 return true; 268 if (!a || !b) 269 return false; 270 return (a->*m_getter)() == (b->*m_getter)(); 271 } 272 273 protected: 274 T (RenderStyle::*m_getter)() const; 275 }; 276 277 template <typename T> 278 class PropertyWrapper : public PropertyWrapperGetter<T> { 279 public: 280 PropertyWrapper(int prop, T (RenderStyle::*getter)() const, void (RenderStyle::*setter)(T)) 281 : PropertyWrapperGetter<T>(prop, getter) 282 , m_setter(setter) 283 { 284 } 285 286 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 287 { 288 (dst->*m_setter)(blendFunc(anim, (a->*PropertyWrapperGetter<T>::m_getter)(), (b->*PropertyWrapperGetter<T>::m_getter)(), progress)); 289 } 290 291 protected: 292 void (RenderStyle::*m_setter)(T); 293 }; 294 295 #if USE(ACCELERATED_COMPOSITING) 296 class PropertyWrapperAcceleratedOpacity : public PropertyWrapper<float> { 297 public: 298 PropertyWrapperAcceleratedOpacity() 299 : PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity) 300 { 301 } 302 303 virtual bool animationIsAccelerated() const { return true; } 304 305 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 306 { 307 float fromOpacity = a->opacity(); 308 309 // This makes sure we put the object being animated into a RenderLayer during the animation 310 dst->setOpacity(blendFunc(anim, (fromOpacity == 1) ? 0.999999f : fromOpacity, b->opacity(), progress)); 311 } 312 }; 313 314 class PropertyWrapperAcceleratedTransform : public PropertyWrapper<const TransformOperations&> { 315 public: 316 PropertyWrapperAcceleratedTransform() 317 : PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform) 318 { 319 } 320 321 virtual bool animationIsAccelerated() const { return true; } 322 323 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 324 { 325 dst->setTransform(blendFunc(anim, a->transform(), b->transform(), progress)); 326 } 327 }; 328 #endif // USE(ACCELERATED_COMPOSITING) 329 330 class PropertyWrapperShadow : public PropertyWrapperBase { 331 public: 332 PropertyWrapperShadow(int prop, const ShadowData* (RenderStyle::*getter)() const, void (RenderStyle::*setter)(ShadowData*, bool)) 333 : PropertyWrapperBase(prop) 334 , m_getter(getter) 335 , m_setter(setter) 336 { 337 } 338 339 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const 340 { 341 const ShadowData* shadowA = (a->*m_getter)(); 342 const ShadowData* shadowB = (b->*m_getter)(); 343 344 while (true) { 345 if (!shadowA && !shadowB) // end of both lists 346 return true; 347 348 if (!shadowA || !shadowB) // end of just one of the lists 349 return false; 350 351 if (*shadowA != *shadowB) 352 return false; 353 354 shadowA = shadowA->next(); 355 shadowB = shadowB->next(); 356 } 357 358 return true; 359 } 360 361 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 362 { 363 const ShadowData* shadowA = (a->*m_getter)(); 364 const ShadowData* shadowB = (b->*m_getter)(); 365 ShadowData defaultShadowData(0, 0, 0, 0, Normal, property() == CSSPropertyWebkitBoxShadow, Color::transparent); 366 ShadowData defaultInsetShadowData(0, 0, 0, 0, Inset, property() == CSSPropertyWebkitBoxShadow, Color::transparent); 367 368 ShadowData* newShadowData = 0; 369 ShadowData* lastShadow = 0; 370 371 while (shadowA || shadowB) { 372 const ShadowData* srcShadow = shadowA ? shadowA : (shadowB->style() == Inset ? &defaultInsetShadowData : &defaultShadowData); 373 const ShadowData* dstShadow = shadowB ? shadowB : (shadowA->style() == Inset ? &defaultInsetShadowData : &defaultShadowData); 374 375 ShadowData* blendedShadow = blendFunc(anim, srcShadow, dstShadow, progress); 376 if (!lastShadow) 377 newShadowData = blendedShadow; 378 else 379 lastShadow->setNext(blendedShadow); 380 381 lastShadow = blendedShadow; 382 383 shadowA = shadowA ? shadowA->next() : 0; 384 shadowB = shadowB ? shadowB->next() : 0; 385 } 386 387 (dst->*m_setter)(newShadowData, false); 388 } 389 390 private: 391 const ShadowData* (RenderStyle::*m_getter)() const; 392 void (RenderStyle::*m_setter)(ShadowData*, bool); 393 }; 394 395 class PropertyWrapperMaybeInvalidColor : public PropertyWrapperBase { 396 public: 397 PropertyWrapperMaybeInvalidColor(int prop, const Color& (RenderStyle::*getter)() const, void (RenderStyle::*setter)(const Color&)) 398 : PropertyWrapperBase(prop) 399 , m_getter(getter) 400 , m_setter(setter) 401 { 402 } 403 404 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const 405 { 406 Color fromColor = (a->*m_getter)(); 407 Color toColor = (b->*m_getter)(); 408 409 if (!fromColor.isValid() && !toColor.isValid()) 410 return true; 411 412 if (!fromColor.isValid()) 413 fromColor = a->color(); 414 if (!toColor.isValid()) 415 toColor = b->color(); 416 417 return fromColor == toColor; 418 } 419 420 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 421 { 422 Color fromColor = (a->*m_getter)(); 423 Color toColor = (b->*m_getter)(); 424 425 if (!fromColor.isValid() && !toColor.isValid()) 426 return; 427 428 if (!fromColor.isValid()) 429 fromColor = a->color(); 430 if (!toColor.isValid()) 431 toColor = b->color(); 432 (dst->*m_setter)(blendFunc(anim, fromColor, toColor, progress)); 433 } 434 435 private: 436 const Color& (RenderStyle::*m_getter)() const; 437 void (RenderStyle::*m_setter)(const Color&); 438 }; 439 440 // Wrapper base class for an animatable property in a FillLayer 441 class FillLayerPropertyWrapperBase { 442 public: 443 FillLayerPropertyWrapperBase() 444 { 445 } 446 447 virtual ~FillLayerPropertyWrapperBase() { } 448 449 virtual bool equals(const FillLayer* a, const FillLayer* b) const = 0; 450 virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const = 0; 451 }; 452 453 template <typename T> 454 class FillLayerPropertyWrapperGetter : public FillLayerPropertyWrapperBase { 455 WTF_MAKE_NONCOPYABLE(FillLayerPropertyWrapperGetter); 456 public: 457 FillLayerPropertyWrapperGetter(T (FillLayer::*getter)() const) 458 : m_getter(getter) 459 { 460 } 461 462 virtual bool equals(const FillLayer* a, const FillLayer* b) const 463 { 464 // If the style pointers are the same, don't bother doing the test. 465 // If either is null, return false. If both are null, return true. 466 if ((!a && !b) || a == b) 467 return true; 468 if (!a || !b) 469 return false; 470 return (a->*m_getter)() == (b->*m_getter)(); 471 } 472 473 protected: 474 T (FillLayer::*m_getter)() const; 475 }; 476 477 template <typename T> 478 class FillLayerPropertyWrapper : public FillLayerPropertyWrapperGetter<T> { 479 public: 480 FillLayerPropertyWrapper(T (FillLayer::*getter)() const, void (FillLayer::*setter)(T)) 481 : FillLayerPropertyWrapperGetter<T>(getter) 482 , m_setter(setter) 483 { 484 } 485 486 virtual void blend(const AnimationBase* anim, FillLayer* dst, const FillLayer* a, const FillLayer* b, double progress) const 487 { 488 (dst->*m_setter)(blendFunc(anim, (a->*FillLayerPropertyWrapperGetter<T>::m_getter)(), (b->*FillLayerPropertyWrapperGetter<T>::m_getter)(), progress)); 489 } 490 491 protected: 492 void (FillLayer::*m_setter)(T); 493 }; 494 495 496 class FillLayersPropertyWrapper : public PropertyWrapperBase { 497 public: 498 typedef const FillLayer* (RenderStyle::*LayersGetter)() const; 499 typedef FillLayer* (RenderStyle::*LayersAccessor)(); 500 501 FillLayersPropertyWrapper(int prop, LayersGetter getter, LayersAccessor accessor) 502 : PropertyWrapperBase(prop) 503 , m_layersGetter(getter) 504 , m_layersAccessor(accessor) 505 { 506 switch (prop) { 507 case CSSPropertyBackgroundPositionX: 508 case CSSPropertyWebkitMaskPositionX: 509 m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<Length>(&FillLayer::xPosition, &FillLayer::setXPosition); 510 break; 511 case CSSPropertyBackgroundPositionY: 512 case CSSPropertyWebkitMaskPositionY: 513 m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<Length>(&FillLayer::yPosition, &FillLayer::setYPosition); 514 break; 515 case CSSPropertyBackgroundSize: 516 case CSSPropertyWebkitBackgroundSize: 517 case CSSPropertyWebkitMaskSize: 518 m_fillLayerPropertyWrapper = new FillLayerPropertyWrapper<LengthSize>(&FillLayer::sizeLength, &FillLayer::setSizeLength); 519 break; 520 } 521 } 522 523 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const 524 { 525 const FillLayer* fromLayer = (a->*m_layersGetter)(); 526 const FillLayer* toLayer = (b->*m_layersGetter)(); 527 528 while (fromLayer && toLayer) { 529 if (!m_fillLayerPropertyWrapper->equals(fromLayer, toLayer)) 530 return false; 531 532 fromLayer = fromLayer->next(); 533 toLayer = toLayer->next(); 534 } 535 536 return true; 537 } 538 539 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 540 { 541 const FillLayer* aLayer = (a->*m_layersGetter)(); 542 const FillLayer* bLayer = (b->*m_layersGetter)(); 543 FillLayer* dstLayer = (dst->*m_layersAccessor)(); 544 545 while (aLayer && bLayer && dstLayer) { 546 m_fillLayerPropertyWrapper->blend(anim, dstLayer, aLayer, bLayer, progress); 547 aLayer = aLayer->next(); 548 bLayer = bLayer->next(); 549 dstLayer = dstLayer->next(); 550 } 551 } 552 553 private: 554 FillLayerPropertyWrapperBase* m_fillLayerPropertyWrapper; 555 556 LayersGetter m_layersGetter; 557 LayersAccessor m_layersAccessor; 558 }; 559 560 class ShorthandPropertyWrapper : public PropertyWrapperBase { 561 public: 562 ShorthandPropertyWrapper(int property, const CSSPropertyLonghand& longhand) 563 : PropertyWrapperBase(property) 564 { 565 for (unsigned i = 0; i < longhand.length(); ++i) { 566 PropertyWrapperBase* wrapper = wrapperForProperty(longhand.properties()[i]); 567 if (wrapper) 568 m_propertyWrappers.append(wrapper); 569 } 570 } 571 572 virtual bool isShorthandWrapper() const { return true; } 573 574 virtual bool equals(const RenderStyle* a, const RenderStyle* b) const 575 { 576 Vector<PropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end(); 577 for (Vector<PropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it) { 578 if (!(*it)->equals(a, b)) 579 return false; 580 } 581 return true; 582 } 583 584 virtual void blend(const AnimationBase* anim, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) const 585 { 586 Vector<PropertyWrapperBase*>::const_iterator end = m_propertyWrappers.end(); 587 for (Vector<PropertyWrapperBase*>::const_iterator it = m_propertyWrappers.begin(); it != end; ++it) 588 (*it)->blend(anim, dst, a, b, progress); 589 } 590 591 const Vector<PropertyWrapperBase*> propertyWrappers() const { return m_propertyWrappers; } 592 593 private: 594 Vector<PropertyWrapperBase*> m_propertyWrappers; 595 }; 596 597 598 static Vector<PropertyWrapperBase*>* gPropertyWrappers = 0; 599 static int gPropertyWrapperMap[numCSSProperties]; 600 601 static const int cInvalidPropertyWrapperIndex = -1; 602 603 604 void AnimationBase::ensurePropertyMap() 605 { 606 // FIXME: This data is never destroyed. Maybe we should ref count it and toss it when the last AnimationController is destroyed? 607 if (gPropertyWrappers == 0) { 608 gPropertyWrappers = new Vector<PropertyWrapperBase*>(); 609 610 // build the list of property wrappers to do the comparisons and blends 611 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyLeft, &RenderStyle::left, &RenderStyle::setLeft)); 612 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyRight, &RenderStyle::right, &RenderStyle::setRight)); 613 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyTop, &RenderStyle::top, &RenderStyle::setTop)); 614 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyBottom, &RenderStyle::bottom, &RenderStyle::setBottom)); 615 616 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyWidth, &RenderStyle::width, &RenderStyle::setWidth)); 617 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMinWidth, &RenderStyle::minWidth, &RenderStyle::setMinWidth)); 618 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMaxWidth, &RenderStyle::maxWidth, &RenderStyle::setMaxWidth)); 619 620 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyHeight, &RenderStyle::height, &RenderStyle::setHeight)); 621 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMinHeight, &RenderStyle::minHeight, &RenderStyle::setMinHeight)); 622 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMaxHeight, &RenderStyle::maxHeight, &RenderStyle::setMaxHeight)); 623 624 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyBorderLeftWidth, &RenderStyle::borderLeftWidth, &RenderStyle::setBorderLeftWidth)); 625 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyBorderRightWidth, &RenderStyle::borderRightWidth, &RenderStyle::setBorderRightWidth)); 626 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyBorderTopWidth, &RenderStyle::borderTopWidth, &RenderStyle::setBorderTopWidth)); 627 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyBorderBottomWidth, &RenderStyle::borderBottomWidth, &RenderStyle::setBorderBottomWidth)); 628 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMarginLeft, &RenderStyle::marginLeft, &RenderStyle::setMarginLeft)); 629 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMarginRight, &RenderStyle::marginRight, &RenderStyle::setMarginRight)); 630 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMarginTop, &RenderStyle::marginTop, &RenderStyle::setMarginTop)); 631 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyMarginBottom, &RenderStyle::marginBottom, &RenderStyle::setMarginBottom)); 632 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyPaddingLeft, &RenderStyle::paddingLeft, &RenderStyle::setPaddingLeft)); 633 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyPaddingRight, &RenderStyle::paddingRight, &RenderStyle::setPaddingRight)); 634 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyPaddingTop, &RenderStyle::paddingTop, &RenderStyle::setPaddingTop)); 635 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyPaddingBottom, &RenderStyle::paddingBottom, &RenderStyle::setPaddingBottom)); 636 gPropertyWrappers->append(new PropertyWrapper<const Color&>(CSSPropertyColor, &RenderStyle::color, &RenderStyle::setColor)); 637 638 gPropertyWrappers->append(new PropertyWrapper<const Color&>(CSSPropertyBackgroundColor, &RenderStyle::backgroundColor, &RenderStyle::setBackgroundColor)); 639 640 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionX, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers)); 641 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyBackgroundPositionY, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers)); 642 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers)); 643 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyWebkitBackgroundSize, &RenderStyle::backgroundLayers, &RenderStyle::accessBackgroundLayers)); 644 645 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionX, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers)); 646 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyWebkitMaskPositionY, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers)); 647 gPropertyWrappers->append(new FillLayersPropertyWrapper(CSSPropertyWebkitMaskSize, &RenderStyle::maskLayers, &RenderStyle::accessMaskLayers)); 648 649 gPropertyWrappers->append(new PropertyWrapper<int>(CSSPropertyFontSize, &RenderStyle::fontSize, &RenderStyle::setBlendedFontSize)); 650 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyWebkitColumnRuleWidth, &RenderStyle::columnRuleWidth, &RenderStyle::setColumnRuleWidth)); 651 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyWebkitColumnGap, &RenderStyle::columnGap, &RenderStyle::setColumnGap)); 652 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyWebkitColumnCount, &RenderStyle::columnCount, &RenderStyle::setColumnCount)); 653 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyWebkitColumnWidth, &RenderStyle::columnWidth, &RenderStyle::setColumnWidth)); 654 gPropertyWrappers->append(new PropertyWrapper<short>(CSSPropertyWebkitBorderHorizontalSpacing, &RenderStyle::horizontalBorderSpacing, &RenderStyle::setHorizontalBorderSpacing)); 655 gPropertyWrappers->append(new PropertyWrapper<short>(CSSPropertyWebkitBorderVerticalSpacing, &RenderStyle::verticalBorderSpacing, &RenderStyle::setVerticalBorderSpacing)); 656 gPropertyWrappers->append(new PropertyWrapper<int>(CSSPropertyZIndex, &RenderStyle::zIndex, &RenderStyle::setZIndex)); 657 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyLineHeight, &RenderStyle::lineHeight, &RenderStyle::setLineHeight)); 658 gPropertyWrappers->append(new PropertyWrapper<int>(CSSPropertyOutlineOffset, &RenderStyle::outlineOffset, &RenderStyle::setOutlineOffset)); 659 gPropertyWrappers->append(new PropertyWrapper<unsigned short>(CSSPropertyOutlineWidth, &RenderStyle::outlineWidth, &RenderStyle::setOutlineWidth)); 660 gPropertyWrappers->append(new PropertyWrapper<int>(CSSPropertyLetterSpacing, &RenderStyle::letterSpacing, &RenderStyle::setLetterSpacing)); 661 gPropertyWrappers->append(new PropertyWrapper<int>(CSSPropertyWordSpacing, &RenderStyle::wordSpacing, &RenderStyle::setWordSpacing)); 662 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyTextIndent, &RenderStyle::textIndent, &RenderStyle::setTextIndent)); 663 664 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyWebkitPerspective, &RenderStyle::perspective, &RenderStyle::setPerspective)); 665 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyWebkitPerspectiveOriginX, &RenderStyle::perspectiveOriginX, &RenderStyle::setPerspectiveOriginX)); 666 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyWebkitPerspectiveOriginY, &RenderStyle::perspectiveOriginY, &RenderStyle::setPerspectiveOriginY)); 667 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyWebkitTransformOriginX, &RenderStyle::transformOriginX, &RenderStyle::setTransformOriginX)); 668 gPropertyWrappers->append(new PropertyWrapper<Length>(CSSPropertyWebkitTransformOriginY, &RenderStyle::transformOriginY, &RenderStyle::setTransformOriginY)); 669 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyWebkitTransformOriginZ, &RenderStyle::transformOriginZ, &RenderStyle::setTransformOriginZ)); 670 gPropertyWrappers->append(new PropertyWrapper<const LengthSize&>(CSSPropertyBorderTopLeftRadius, &RenderStyle::borderTopLeftRadius, &RenderStyle::setBorderTopLeftRadius)); 671 gPropertyWrappers->append(new PropertyWrapper<const LengthSize&>(CSSPropertyBorderTopRightRadius, &RenderStyle::borderTopRightRadius, &RenderStyle::setBorderTopRightRadius)); 672 gPropertyWrappers->append(new PropertyWrapper<const LengthSize&>(CSSPropertyBorderBottomLeftRadius, &RenderStyle::borderBottomLeftRadius, &RenderStyle::setBorderBottomLeftRadius)); 673 gPropertyWrappers->append(new PropertyWrapper<const LengthSize&>(CSSPropertyBorderBottomRightRadius, &RenderStyle::borderBottomRightRadius, &RenderStyle::setBorderBottomRightRadius)); 674 gPropertyWrappers->append(new PropertyWrapper<EVisibility>(CSSPropertyVisibility, &RenderStyle::visibility, &RenderStyle::setVisibility)); 675 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyZoom, &RenderStyle::zoom, &RenderStyle::setZoom)); 676 677 gPropertyWrappers->append(new PropertyWrapper<LengthBox>(CSSPropertyClip, &RenderStyle::clip, &RenderStyle::setClip)); 678 679 #if USE(ACCELERATED_COMPOSITING) 680 gPropertyWrappers->append(new PropertyWrapperAcceleratedOpacity()); 681 gPropertyWrappers->append(new PropertyWrapperAcceleratedTransform()); 682 #else 683 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyOpacity, &RenderStyle::opacity, &RenderStyle::setOpacity)); 684 gPropertyWrappers->append(new PropertyWrapper<const TransformOperations&>(CSSPropertyWebkitTransform, &RenderStyle::transform, &RenderStyle::setTransform)); 685 #endif 686 687 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyWebkitColumnRuleColor, &RenderStyle::columnRuleColor, &RenderStyle::setColumnRuleColor)); 688 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyWebkitTextStrokeColor, &RenderStyle::textStrokeColor, &RenderStyle::setTextStrokeColor)); 689 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyWebkitTextFillColor, &RenderStyle::textFillColor, &RenderStyle::setTextFillColor)); 690 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyBorderLeftColor, &RenderStyle::borderLeftColor, &RenderStyle::setBorderLeftColor)); 691 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyBorderRightColor, &RenderStyle::borderRightColor, &RenderStyle::setBorderRightColor)); 692 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyBorderTopColor, &RenderStyle::borderTopColor, &RenderStyle::setBorderTopColor)); 693 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyBorderBottomColor, &RenderStyle::borderBottomColor, &RenderStyle::setBorderBottomColor)); 694 gPropertyWrappers->append(new PropertyWrapperMaybeInvalidColor(CSSPropertyOutlineColor, &RenderStyle::outlineColor, &RenderStyle::setOutlineColor)); 695 696 gPropertyWrappers->append(new PropertyWrapperShadow(CSSPropertyBoxShadow, &RenderStyle::boxShadow, &RenderStyle::setBoxShadow)); 697 gPropertyWrappers->append(new PropertyWrapperShadow(CSSPropertyWebkitBoxShadow, &RenderStyle::boxShadow, &RenderStyle::setBoxShadow)); 698 gPropertyWrappers->append(new PropertyWrapperShadow(CSSPropertyTextShadow, &RenderStyle::textShadow, &RenderStyle::setTextShadow)); 699 700 #if ENABLE(SVG) 701 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyFillOpacity, &RenderStyle::fillOpacity, &RenderStyle::setFillOpacity)); 702 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyFloodOpacity, &RenderStyle::floodOpacity, &RenderStyle::setFloodOpacity)); 703 gPropertyWrappers->append(new PropertyWrapper<float>(CSSPropertyStrokeOpacity, &RenderStyle::strokeOpacity, &RenderStyle::setStrokeOpacity)); 704 #endif 705 706 // TODO: 707 // 708 // CSSPropertyVerticalAlign 709 // 710 // Compound properties that have components that should be animatable: 711 // 712 // CSSPropertyWebkitColumns 713 // CSSPropertyWebkitBoxReflect 714 715 // Make sure unused slots have a value 716 for (unsigned int i = 0; i < static_cast<unsigned int>(numCSSProperties); ++i) 717 gPropertyWrapperMap[i] = cInvalidPropertyWrapperIndex; 718 719 // First we put the non-shorthand property wrappers into the map, so the shorthand-building 720 // code can find them. 721 size_t n = gPropertyWrappers->size(); 722 for (unsigned int i = 0; i < n; ++i) { 723 ASSERT((*gPropertyWrappers)[i]->property() - firstCSSProperty < numCSSProperties); 724 gPropertyWrapperMap[(*gPropertyWrappers)[i]->property() - firstCSSProperty] = i; 725 } 726 727 // Now add the shorthand wrappers. 728 addShorthandProperties(); 729 } 730 } 731 732 static void addPropertyWrapper(int propertyID, PropertyWrapperBase* wrapper) 733 { 734 int propIndex = propertyID - firstCSSProperty; 735 736 ASSERT(gPropertyWrapperMap[propIndex] == cInvalidPropertyWrapperIndex); 737 738 unsigned wrapperIndex = gPropertyWrappers->size(); 739 gPropertyWrappers->append(wrapper); 740 gPropertyWrapperMap[propIndex] = wrapperIndex; 741 } 742 743 static void addShorthandProperties() 744 { 745 static const int animatableShorthandProperties[] = { 746 CSSPropertyBackground, // for background-color, background-position 747 CSSPropertyBackgroundPosition, 748 CSSPropertyWebkitMask, // for mask-position 749 CSSPropertyWebkitMaskPosition, 750 CSSPropertyBorderTop, CSSPropertyBorderRight, CSSPropertyBorderBottom, CSSPropertyBorderLeft, 751 CSSPropertyBorderColor, 752 CSSPropertyBorderRadius, 753 CSSPropertyBorderWidth, 754 CSSPropertyBorder, 755 CSSPropertyBorderSpacing, 756 CSSPropertyMargin, 757 CSSPropertyOutline, 758 CSSPropertyPadding, 759 CSSPropertyWebkitTextStroke, 760 CSSPropertyWebkitColumnRule, 761 CSSPropertyWebkitBorderRadius, 762 CSSPropertyWebkitTransformOrigin 763 }; 764 765 for (size_t i = 0; i < WTF_ARRAY_LENGTH(animatableShorthandProperties); ++i) { 766 int propertyID = animatableShorthandProperties[i]; 767 CSSPropertyLonghand longhand = longhandForProperty(propertyID); 768 if (longhand.length() > 0) 769 addPropertyWrapper(propertyID, new ShorthandPropertyWrapper(propertyID, longhand)); 770 } 771 772 // 'font' is not in the shorthand map. 773 static const int animatableFontProperties[] = { 774 CSSPropertyFontSize, 775 CSSPropertyFontWeight 776 }; 777 778 CSSPropertyLonghand fontLonghand(animatableFontProperties, WTF_ARRAY_LENGTH(animatableFontProperties)); 779 addPropertyWrapper(CSSPropertyFont, new ShorthandPropertyWrapper(CSSPropertyFont, fontLonghand)); 780 } 781 782 static PropertyWrapperBase* wrapperForProperty(int propertyID) 783 { 784 int propIndex = propertyID - firstCSSProperty; 785 if (propIndex >= 0 && propIndex < numCSSProperties) { 786 int wrapperIndex = gPropertyWrapperMap[propIndex]; 787 if (wrapperIndex >= 0) 788 return (*gPropertyWrappers)[wrapperIndex]; 789 } 790 return 0; 791 } 792 793 AnimationBase::AnimationBase(const Animation* transition, RenderObject* renderer, CompositeAnimation* compAnim) 794 : m_animState(AnimationStateNew) 795 , m_isAnimating(false) 796 , m_startTime(0) 797 , m_pauseTime(-1) 798 , m_requestedStartTime(0) 799 , m_object(renderer) 800 , m_animation(const_cast<Animation*>(transition)) 801 , m_compAnim(compAnim) 802 , m_isAccelerated(false) 803 , m_transformFunctionListValid(false) 804 , m_nextIterationDuration(-1) 805 { 806 // Compute the total duration 807 m_totalDuration = -1; 808 if (m_animation->iterationCount() > 0) 809 m_totalDuration = m_animation->duration() * m_animation->iterationCount(); 810 } 811 812 bool AnimationBase::propertiesEqual(int prop, const RenderStyle* a, const RenderStyle* b) 813 { 814 ensurePropertyMap(); 815 if (prop == cAnimateAll) { 816 size_t n = gPropertyWrappers->size(); 817 for (unsigned int i = 0; i < n; ++i) { 818 PropertyWrapperBase* wrapper = (*gPropertyWrappers)[i]; 819 // No point comparing shorthand wrappers for 'all'. 820 if (!wrapper->isShorthandWrapper() && !wrapper->equals(a, b)) 821 return false; 822 } 823 } else { 824 PropertyWrapperBase* wrapper = wrapperForProperty(prop); 825 if (wrapper) 826 return wrapper->equals(a, b); 827 } 828 return true; 829 } 830 831 int AnimationBase::getPropertyAtIndex(int i, bool& isShorthand) 832 { 833 ensurePropertyMap(); 834 if (i < 0 || i >= static_cast<int>(gPropertyWrappers->size())) 835 return CSSPropertyInvalid; 836 837 PropertyWrapperBase* wrapper = (*gPropertyWrappers)[i]; 838 isShorthand = wrapper->isShorthandWrapper(); 839 return wrapper->property(); 840 } 841 842 int AnimationBase::getNumProperties() 843 { 844 ensurePropertyMap(); 845 return gPropertyWrappers->size(); 846 } 847 848 // Returns true if we need to start animation timers 849 bool AnimationBase::blendProperties(const AnimationBase* anim, int prop, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress) 850 { 851 ASSERT(prop != cAnimateAll); 852 853 ensurePropertyMap(); 854 PropertyWrapperBase* wrapper = wrapperForProperty(prop); 855 if (wrapper) { 856 wrapper->blend(anim, dst, a, b, progress); 857 #if USE(ACCELERATED_COMPOSITING) 858 return !wrapper->animationIsAccelerated() || !anim->isAccelerated(); 859 #else 860 return true; 861 #endif 862 } 863 864 return false; 865 } 866 867 #if USE(ACCELERATED_COMPOSITING) 868 bool AnimationBase::animationOfPropertyIsAccelerated(int prop) 869 { 870 ensurePropertyMap(); 871 PropertyWrapperBase* wrapper = wrapperForProperty(prop); 872 return wrapper ? wrapper->animationIsAccelerated() : false; 873 } 874 #endif 875 876 static bool gatherEnclosingShorthandProperties(int property, PropertyWrapperBase* wrapper, HashSet<int>& propertySet) 877 { 878 if (!wrapper->isShorthandWrapper()) 879 return false; 880 881 ShorthandPropertyWrapper* shorthandWrapper = static_cast<ShorthandPropertyWrapper*>(wrapper); 882 883 bool contained = false; 884 for (size_t i = 0; i < shorthandWrapper->propertyWrappers().size(); ++i) { 885 PropertyWrapperBase* currWrapper = shorthandWrapper->propertyWrappers()[i]; 886 887 if (gatherEnclosingShorthandProperties(property, currWrapper, propertySet) || currWrapper->property() == property) 888 contained = true; 889 } 890 891 if (contained) 892 propertySet.add(wrapper->property()); 893 894 return contained; 895 } 896 897 // Note: this is inefficient. It's only called from pauseTransitionAtTime(). 898 HashSet<int> AnimationBase::animatableShorthandsAffectingProperty(int property) 899 { 900 ensurePropertyMap(); 901 902 HashSet<int> foundProperties; 903 for (int i = 0; i < getNumProperties(); ++i) 904 gatherEnclosingShorthandProperties(property, (*gPropertyWrappers)[i], foundProperties); 905 906 return foundProperties; 907 } 908 909 void AnimationBase::setNeedsStyleRecalc(Node* node) 910 { 911 ASSERT(!node || (node->document() && !node->document()->inPageCache())); 912 if (node) 913 node->setNeedsStyleRecalc(SyntheticStyleChange); 914 } 915 916 double AnimationBase::duration() const 917 { 918 return m_animation->duration(); 919 } 920 921 bool AnimationBase::playStatePlaying() const 922 { 923 return m_animation->playState() == AnimPlayStatePlaying; 924 } 925 926 bool AnimationBase::animationsMatch(const Animation* anim) const 927 { 928 return m_animation->animationsMatch(anim); 929 } 930 931 void AnimationBase::updateStateMachine(AnimStateInput input, double param) 932 { 933 if (!m_compAnim) 934 return; 935 936 // If we get AnimationStateInputRestartAnimation then we force a new animation, regardless of state. 937 if (input == AnimationStateInputMakeNew) { 938 if (m_animState == AnimationStateStartWaitStyleAvailable) 939 m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); 940 m_animState = AnimationStateNew; 941 m_startTime = 0; 942 m_pauseTime = -1; 943 m_requestedStartTime = 0; 944 m_nextIterationDuration = -1; 945 endAnimation(); 946 return; 947 } 948 949 if (input == AnimationStateInputRestartAnimation) { 950 if (m_animState == AnimationStateStartWaitStyleAvailable) 951 m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); 952 m_animState = AnimationStateNew; 953 m_startTime = 0; 954 m_pauseTime = -1; 955 m_requestedStartTime = 0; 956 m_nextIterationDuration = -1; 957 endAnimation(); 958 959 if (!paused()) 960 updateStateMachine(AnimationStateInputStartAnimation, -1); 961 return; 962 } 963 964 if (input == AnimationStateInputEndAnimation) { 965 if (m_animState == AnimationStateStartWaitStyleAvailable) 966 m_compAnim->animationController()->removeFromAnimationsWaitingForStyle(this); 967 m_animState = AnimationStateDone; 968 endAnimation(); 969 return; 970 } 971 972 if (input == AnimationStateInputPauseOverride) { 973 if (m_animState == AnimationStateStartWaitResponse) { 974 // If we are in AnimationStateStartWaitResponse, the animation will get canceled before 975 // we get a response, so move to the next state. 976 endAnimation(); 977 updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); 978 } 979 return; 980 } 981 982 if (input == AnimationStateInputResumeOverride) { 983 if (m_animState == AnimationStateLooping || m_animState == AnimationStateEnding) { 984 // Start the animation 985 startAnimation(beginAnimationUpdateTime() - m_startTime); 986 } 987 return; 988 } 989 990 // Execute state machine 991 switch (m_animState) { 992 case AnimationStateNew: 993 ASSERT(input == AnimationStateInputStartAnimation || input == AnimationStateInputPlayStateRunning || input == AnimationStateInputPlayStatePaused); 994 if (input == AnimationStateInputStartAnimation || input == AnimationStateInputPlayStateRunning) { 995 m_requestedStartTime = beginAnimationUpdateTime(); 996 m_animState = AnimationStateStartWaitTimer; 997 } 998 break; 999 case AnimationStateStartWaitTimer: 1000 ASSERT(input == AnimationStateInputStartTimerFired || input == AnimationStateInputPlayStatePaused); 1001 1002 if (input == AnimationStateInputStartTimerFired) { 1003 ASSERT(param >= 0); 1004 // Start timer has fired, tell the animation to start and wait for it to respond with start time 1005 m_animState = AnimationStateStartWaitStyleAvailable; 1006 m_compAnim->animationController()->addToAnimationsWaitingForStyle(this); 1007 1008 // Trigger a render so we can start the animation 1009 if (m_object) 1010 m_compAnim->animationController()->addNodeChangeToDispatch(m_object->node()); 1011 } else { 1012 ASSERT(!paused()); 1013 // We're waiting for the start timer to fire and we got a pause. Cancel the timer, pause and wait 1014 m_pauseTime = beginAnimationUpdateTime(); 1015 m_animState = AnimationStatePausedWaitTimer; 1016 } 1017 break; 1018 case AnimationStateStartWaitStyleAvailable: 1019 ASSERT(input == AnimationStateInputStyleAvailable || input == AnimationStateInputPlayStatePaused); 1020 1021 if (input == AnimationStateInputStyleAvailable) { 1022 // Start timer has fired, tell the animation to start and wait for it to respond with start time 1023 m_animState = AnimationStateStartWaitResponse; 1024 1025 overrideAnimations(); 1026 1027 // Start the animation 1028 if (overridden()) { 1029 // We won't try to start accelerated animations if we are overridden and 1030 // just move on to the next state. 1031 m_animState = AnimationStateStartWaitResponse; 1032 m_isAccelerated = false; 1033 updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); 1034 } else { 1035 double timeOffset = 0; 1036 // If the value for 'animation-delay' is negative then the animation appears to have started in the past. 1037 if (m_animation->delay() < 0) 1038 timeOffset = -m_animation->delay(); 1039 bool started = startAnimation(timeOffset); 1040 1041 m_compAnim->animationController()->addToAnimationsWaitingForStartTimeResponse(this, started); 1042 m_isAccelerated = started; 1043 } 1044 } else { 1045 // We're waiting for the style to be available and we got a pause. Pause and wait 1046 m_pauseTime = beginAnimationUpdateTime(); 1047 m_animState = AnimationStatePausedWaitStyleAvailable; 1048 } 1049 break; 1050 case AnimationStateStartWaitResponse: 1051 ASSERT(input == AnimationStateInputStartTimeSet || input == AnimationStateInputPlayStatePaused); 1052 1053 if (input == AnimationStateInputStartTimeSet) { 1054 ASSERT(param >= 0); 1055 // We have a start time, set it, unless the startTime is already set 1056 if (m_startTime <= 0) { 1057 m_startTime = param; 1058 // If the value for 'animation-delay' is negative then the animation appears to have started in the past. 1059 if (m_animation->delay() < 0) 1060 m_startTime += m_animation->delay(); 1061 } 1062 1063 // Now that we know the start time, fire the start event. 1064 onAnimationStart(0); // The elapsedTime is 0. 1065 1066 // Decide whether to go into looping or ending state 1067 goIntoEndingOrLoopingState(); 1068 1069 // Dispatch updateStyleIfNeeded so we can start the animation 1070 if (m_object) 1071 m_compAnim->animationController()->addNodeChangeToDispatch(m_object->node()); 1072 } else { 1073 // We are pausing while waiting for a start response. Cancel the animation and wait. When 1074 // we unpause, we will act as though the start timer just fired 1075 m_pauseTime = beginAnimationUpdateTime(); 1076 pauseAnimation(beginAnimationUpdateTime() - m_startTime); 1077 m_animState = AnimationStatePausedWaitResponse; 1078 } 1079 break; 1080 case AnimationStateLooping: 1081 ASSERT(input == AnimationStateInputLoopTimerFired || input == AnimationStateInputPlayStatePaused); 1082 1083 if (input == AnimationStateInputLoopTimerFired) { 1084 ASSERT(param >= 0); 1085 // Loop timer fired, loop again or end. 1086 onAnimationIteration(param); 1087 1088 // Decide whether to go into looping or ending state 1089 goIntoEndingOrLoopingState(); 1090 } else { 1091 // We are pausing while running. Cancel the animation and wait 1092 m_pauseTime = beginAnimationUpdateTime(); 1093 pauseAnimation(beginAnimationUpdateTime() - m_startTime); 1094 m_animState = AnimationStatePausedRun; 1095 } 1096 break; 1097 case AnimationStateEnding: 1098 ASSERT(input == AnimationStateInputEndTimerFired || input == AnimationStateInputPlayStatePaused); 1099 1100 if (input == AnimationStateInputEndTimerFired) { 1101 1102 ASSERT(param >= 0); 1103 // End timer fired, finish up 1104 onAnimationEnd(param); 1105 1106 m_animState = AnimationStateDone; 1107 1108 if (m_object) { 1109 if (m_animation->fillsForwards()) 1110 m_animState = AnimationStateFillingForwards; 1111 else 1112 resumeOverriddenAnimations(); 1113 1114 // Fire off another style change so we can set the final value 1115 m_compAnim->animationController()->addNodeChangeToDispatch(m_object->node()); 1116 } 1117 } else { 1118 // We are pausing while running. Cancel the animation and wait 1119 m_pauseTime = beginAnimationUpdateTime(); 1120 pauseAnimation(beginAnimationUpdateTime() - m_startTime); 1121 m_animState = AnimationStatePausedRun; 1122 } 1123 // |this| may be deleted here 1124 break; 1125 case AnimationStatePausedWaitTimer: 1126 ASSERT(input == AnimationStateInputPlayStateRunning); 1127 ASSERT(paused()); 1128 // Update the times 1129 m_startTime += beginAnimationUpdateTime() - m_pauseTime; 1130 m_pauseTime = -1; 1131 1132 // we were waiting for the start timer to fire, go back and wait again 1133 m_animState = AnimationStateNew; 1134 updateStateMachine(AnimationStateInputStartAnimation, 0); 1135 break; 1136 case AnimationStatePausedWaitResponse: 1137 case AnimationStatePausedWaitStyleAvailable: 1138 case AnimationStatePausedRun: 1139 // We treat these two cases the same. The only difference is that, when we are in 1140 // AnimationStatePausedWaitResponse, we don't yet have a valid startTime, so we send 0 to startAnimation. 1141 // When the AnimationStateInputStartTimeSet comes in and we were in AnimationStatePausedRun, we will notice 1142 // that we have already set the startTime and will ignore it. 1143 ASSERT(input == AnimationStateInputPlayStateRunning || input == AnimationStateInputStartTimeSet || input == AnimationStateInputStyleAvailable); 1144 ASSERT(paused()); 1145 1146 if (input == AnimationStateInputPlayStateRunning) { 1147 // Update the times 1148 if (m_animState == AnimationStatePausedRun) 1149 m_startTime += beginAnimationUpdateTime() - m_pauseTime; 1150 else 1151 m_startTime = 0; 1152 m_pauseTime = -1; 1153 1154 if (m_animState == AnimationStatePausedWaitStyleAvailable) 1155 m_animState = AnimationStateStartWaitStyleAvailable; 1156 else { 1157 // We were either running or waiting for a begin time response from the animation. 1158 // Either way we need to restart the animation (possibly with an offset if we 1159 // had already been running) and wait for it to start. 1160 m_animState = AnimationStateStartWaitResponse; 1161 1162 // Start the animation 1163 if (overridden()) { 1164 // We won't try to start accelerated animations if we are overridden and 1165 // just move on to the next state. 1166 updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime()); 1167 m_isAccelerated = true; 1168 } else { 1169 bool started = startAnimation(beginAnimationUpdateTime() - m_startTime); 1170 m_compAnim->animationController()->addToAnimationsWaitingForStartTimeResponse(this, started); 1171 m_isAccelerated = started; 1172 } 1173 } 1174 break; 1175 } 1176 1177 if (input == AnimationStateInputStartTimeSet) { 1178 ASSERT(m_animState == AnimationStatePausedWaitResponse); 1179 1180 // We are paused but we got the callback that notifies us that an accelerated animation started. 1181 // We ignore the start time and just move into the paused-run state. 1182 m_animState = AnimationStatePausedRun; 1183 ASSERT(m_startTime == 0); 1184 m_startTime = param; 1185 m_pauseTime += m_startTime; 1186 break; 1187 } 1188 1189 ASSERT(m_animState == AnimationStatePausedWaitStyleAvailable); 1190 // We are paused but we got the callback that notifies us that style has been updated. 1191 // We move to the AnimationStatePausedWaitResponse state 1192 m_animState = AnimationStatePausedWaitResponse; 1193 overrideAnimations(); 1194 break; 1195 case AnimationStateFillingForwards: 1196 case AnimationStateDone: 1197 // We're done. Stay in this state until we are deleted 1198 break; 1199 } 1200 } 1201 1202 void AnimationBase::fireAnimationEventsIfNeeded() 1203 { 1204 if (!m_compAnim) 1205 return; 1206 1207 // If we are waiting for the delay time to expire and it has, go to the next state 1208 if (m_animState != AnimationStateStartWaitTimer && m_animState != AnimationStateLooping && m_animState != AnimationStateEnding) 1209 return; 1210 1211 // We have to make sure to keep a ref to the this pointer, because it could get destroyed 1212 // during an animation callback that might get called. Since the owner is a CompositeAnimation 1213 // and it ref counts this object, we will keep a ref to that instead. That way the AnimationBase 1214 // can still access the resources of its CompositeAnimation as needed. 1215 RefPtr<AnimationBase> protector(this); 1216 RefPtr<CompositeAnimation> compProtector(m_compAnim); 1217 1218 // Check for start timeout 1219 if (m_animState == AnimationStateStartWaitTimer) { 1220 if (beginAnimationUpdateTime() - m_requestedStartTime >= m_animation->delay()) 1221 updateStateMachine(AnimationStateInputStartTimerFired, 0); 1222 return; 1223 } 1224 1225 double elapsedDuration = beginAnimationUpdateTime() - m_startTime; 1226 // FIXME: we need to ensure that elapsedDuration is never < 0. If it is, this suggests that 1227 // we had a recalcStyle() outside of beginAnimationUpdate()/endAnimationUpdate(). 1228 // Also check in getTimeToNextEvent(). 1229 elapsedDuration = max(elapsedDuration, 0.0); 1230 1231 // Check for end timeout 1232 if (m_totalDuration >= 0 && elapsedDuration >= m_totalDuration) { 1233 // We may still be in AnimationStateLooping if we've managed to skip a 1234 // whole iteration, in which case we should jump to the end state. 1235 m_animState = AnimationStateEnding; 1236 1237 // Fire an end event 1238 updateStateMachine(AnimationStateInputEndTimerFired, m_totalDuration); 1239 } else { 1240 // Check for iteration timeout 1241 if (m_nextIterationDuration < 0) { 1242 // Hasn't been set yet, set it 1243 double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration()); 1244 m_nextIterationDuration = elapsedDuration + durationLeft; 1245 } 1246 1247 if (elapsedDuration >= m_nextIterationDuration) { 1248 // Set to the next iteration 1249 double previous = m_nextIterationDuration; 1250 double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration()); 1251 m_nextIterationDuration = elapsedDuration + durationLeft; 1252 1253 // Send the event 1254 updateStateMachine(AnimationStateInputLoopTimerFired, previous); 1255 } 1256 } 1257 } 1258 1259 void AnimationBase::updatePlayState(EAnimPlayState playState) 1260 { 1261 if (!m_compAnim) 1262 return; 1263 1264 // When we get here, we can have one of 4 desired states: running, paused, suspended, paused & suspended. 1265 // The state machine can be in one of two states: running, paused. 1266 // Set the state machine to the desired state. 1267 bool pause = playState == AnimPlayStatePaused || m_compAnim->suspended(); 1268 1269 if (pause == paused() && !isNew()) 1270 return; 1271 1272 updateStateMachine(pause ? AnimationStateInputPlayStatePaused : AnimationStateInputPlayStateRunning, -1); 1273 } 1274 1275 double AnimationBase::timeToNextService() 1276 { 1277 // Returns the time at which next service is required. -1 means no service is required. 0 means 1278 // service is required now, and > 0 means service is required that many seconds in the future. 1279 if (paused() || isNew() || m_animState == AnimationStateFillingForwards) 1280 return -1; 1281 1282 if (m_animState == AnimationStateStartWaitTimer) { 1283 double timeFromNow = m_animation->delay() - (beginAnimationUpdateTime() - m_requestedStartTime); 1284 return max(timeFromNow, 0.0); 1285 } 1286 1287 fireAnimationEventsIfNeeded(); 1288 1289 // In all other cases, we need service right away. 1290 return 0; 1291 } 1292 1293 double AnimationBase::progress(double scale, double offset, const TimingFunction* tf) const 1294 { 1295 if (preActive()) 1296 return 0; 1297 1298 double elapsedTime = getElapsedTime(); 1299 1300 double dur = m_animation->duration(); 1301 if (m_animation->iterationCount() > 0) 1302 dur *= m_animation->iterationCount(); 1303 1304 if (postActive() || !m_animation->duration()) 1305 return 1.0; 1306 if (m_animation->iterationCount() > 0 && elapsedTime >= dur) 1307 return (m_animation->iterationCount() % 2) ? 1.0 : 0.0; 1308 1309 // Compute the fractional time, taking into account direction. 1310 // There is no need to worry about iterations, we assume that we would have 1311 // short circuited above if we were done. 1312 double fractionalTime = elapsedTime / m_animation->duration(); 1313 int integralTime = static_cast<int>(fractionalTime); 1314 fractionalTime -= integralTime; 1315 1316 if ((m_animation->direction() == Animation::AnimationDirectionAlternate) && (integralTime & 1)) 1317 fractionalTime = 1 - fractionalTime; 1318 1319 if (scale != 1 || offset) 1320 fractionalTime = (fractionalTime - offset) * scale; 1321 1322 if (!tf) 1323 tf = m_animation->timingFunction().get(); 1324 1325 if (tf->isCubicBezierTimingFunction()) { 1326 const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(tf); 1327 return solveCubicBezierFunction(ctf->x1(), 1328 ctf->y1(), 1329 ctf->x2(), 1330 ctf->y2(), 1331 fractionalTime, m_animation->duration()); 1332 } else if (tf->isStepsTimingFunction()) { 1333 const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(tf); 1334 return solveStepsFunction(stf->numberOfSteps(), stf->stepAtStart(), fractionalTime); 1335 } else 1336 return fractionalTime; 1337 } 1338 1339 void AnimationBase::getTimeToNextEvent(double& time, bool& isLooping) const 1340 { 1341 // Decide when the end or loop event needs to fire 1342 const double elapsedDuration = max(beginAnimationUpdateTime() - m_startTime, 0.0); 1343 double durationLeft = 0; 1344 double nextIterationTime = m_totalDuration; 1345 1346 if (m_totalDuration < 0 || elapsedDuration < m_totalDuration) { 1347 durationLeft = m_animation->duration() > 0 ? (m_animation->duration() - fmod(elapsedDuration, m_animation->duration())) : 0; 1348 nextIterationTime = elapsedDuration + durationLeft; 1349 } 1350 1351 if (m_totalDuration < 0 || nextIterationTime < m_totalDuration) { 1352 // We are not at the end yet 1353 ASSERT(nextIterationTime > 0); 1354 isLooping = true; 1355 } else { 1356 // We are at the end 1357 isLooping = false; 1358 } 1359 1360 time = durationLeft; 1361 } 1362 1363 void AnimationBase::goIntoEndingOrLoopingState() 1364 { 1365 double t; 1366 bool isLooping; 1367 getTimeToNextEvent(t, isLooping); 1368 m_animState = isLooping ? AnimationStateLooping : AnimationStateEnding; 1369 } 1370 1371 void AnimationBase::freezeAtTime(double t) 1372 { 1373 if (!m_compAnim) 1374 return; 1375 1376 if (!m_startTime) { 1377 // If we haven't started yet, just generate the start event now 1378 m_compAnim->animationController()->receivedStartTimeResponse(currentTime()); 1379 } 1380 1381 ASSERT(m_startTime); // if m_startTime is zero, we haven't started yet, so we'll get a bad pause time. 1382 m_pauseTime = m_startTime + t - m_animation->delay(); 1383 1384 #if USE(ACCELERATED_COMPOSITING) 1385 if (m_object && m_object->hasLayer()) { 1386 RenderLayer* layer = toRenderBoxModelObject(m_object)->layer(); 1387 if (layer->isComposited()) 1388 layer->backing()->suspendAnimations(m_pauseTime); 1389 } 1390 #endif 1391 } 1392 1393 double AnimationBase::beginAnimationUpdateTime() const 1394 { 1395 if (!m_compAnim) 1396 return 0; 1397 1398 return m_compAnim->animationController()->beginAnimationUpdateTime(); 1399 } 1400 1401 double AnimationBase::getElapsedTime() const 1402 { 1403 if (paused()) 1404 return m_pauseTime - m_startTime; 1405 if (m_startTime <= 0) 1406 return 0; 1407 if (postActive()) 1408 return 1; 1409 1410 return beginAnimationUpdateTime() - m_startTime; 1411 } 1412 1413 void AnimationBase::setElapsedTime(double time) 1414 { 1415 // FIXME: implement this method 1416 UNUSED_PARAM(time); 1417 } 1418 1419 void AnimationBase::play() 1420 { 1421 // FIXME: implement this method 1422 } 1423 1424 void AnimationBase::pause() 1425 { 1426 // FIXME: implement this method 1427 } 1428 1429 } // namespace WebCore 1430
