Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim:set ts=2 sw=2 sts=2 et cindent: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #include "mozilla/dom/AnimationEffectTiming.h"
       8             : 
       9             : #include "mozilla/dom/AnimatableBinding.h"
      10             : #include "mozilla/dom/AnimationEffectTimingBinding.h"
      11             : #include "mozilla/dom/KeyframeEffect.h"
      12             : #include "mozilla/TimingParams.h"
      13             : #include "nsAString.h"
      14             : 
      15             : namespace mozilla {
      16             : namespace dom {
      17             : 
      18             : JSObject*
      19           0 : AnimationEffectTiming::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
      20             : {
      21           0 :   return AnimationEffectTimingBinding::Wrap(aCx, this, aGivenProto);
      22             : }
      23             : 
      24             : static inline void
      25           0 : PostSpecifiedTimingUpdated(KeyframeEffect* aEffect)
      26             : {
      27           0 :   if (aEffect) {
      28           0 :     aEffect->NotifySpecifiedTimingUpdated();
      29             :   }
      30           0 : }
      31             : 
      32             : void
      33           0 : AnimationEffectTiming::SetDelay(double aDelay)
      34             : {
      35           0 :   TimeDuration delay = TimeDuration::FromMilliseconds(aDelay);
      36           0 :   if (mTiming.Delay() == delay) {
      37           0 :     return;
      38             :   }
      39           0 :   mTiming.SetDelay(delay);
      40             : 
      41           0 :   PostSpecifiedTimingUpdated(mEffect);
      42             : }
      43             : 
      44             : void
      45           0 : AnimationEffectTiming::SetEndDelay(double aEndDelay)
      46             : {
      47           0 :   TimeDuration endDelay = TimeDuration::FromMilliseconds(aEndDelay);
      48           0 :   if (mTiming.EndDelay() == endDelay) {
      49           0 :     return;
      50             :   }
      51           0 :   mTiming.SetEndDelay(endDelay);
      52             : 
      53           0 :   PostSpecifiedTimingUpdated(mEffect);
      54             : }
      55             : 
      56             : void
      57           0 : AnimationEffectTiming::SetFill(const FillMode& aFill)
      58             : {
      59           0 :   if (mTiming.Fill() == aFill) {
      60           0 :     return;
      61             :   }
      62           0 :   mTiming.SetFill(aFill);
      63             : 
      64           0 :   PostSpecifiedTimingUpdated(mEffect);
      65             : }
      66             : 
      67             : void
      68           0 : AnimationEffectTiming::SetIterationStart(double aIterationStart,
      69             :                                          ErrorResult& aRv)
      70             : {
      71           0 :   if (mTiming.IterationStart() == aIterationStart) {
      72           0 :     return;
      73             :   }
      74             : 
      75           0 :   TimingParams::ValidateIterationStart(aIterationStart, aRv);
      76           0 :   if (aRv.Failed()) {
      77           0 :     return;
      78             :   }
      79             : 
      80           0 :   mTiming.SetIterationStart(aIterationStart);
      81             : 
      82           0 :   PostSpecifiedTimingUpdated(mEffect);
      83             : }
      84             : 
      85             : void
      86           0 : AnimationEffectTiming::SetIterations(double aIterations, ErrorResult& aRv)
      87             : {
      88           0 :   if (mTiming.Iterations() == aIterations) {
      89           0 :     return;
      90             :   }
      91             : 
      92           0 :   TimingParams::ValidateIterations(aIterations, aRv);
      93           0 :   if (aRv.Failed()) {
      94           0 :     return;
      95             :   }
      96             : 
      97           0 :   mTiming.SetIterations(aIterations);
      98             : 
      99           0 :   PostSpecifiedTimingUpdated(mEffect);
     100             : }
     101             : 
     102             : void
     103           0 : AnimationEffectTiming::SetDuration(const UnrestrictedDoubleOrString& aDuration,
     104             :                                    ErrorResult& aRv)
     105             : {
     106             :   Maybe<StickyTimeDuration> newDuration =
     107           0 :     TimingParams::ParseDuration(aDuration, aRv);
     108           0 :   if (aRv.Failed()) {
     109           0 :     return;
     110             :   }
     111             : 
     112           0 :   if (mTiming.Duration() == newDuration) {
     113           0 :     return;
     114             :   }
     115             : 
     116           0 :   mTiming.SetDuration(Move(newDuration));
     117             : 
     118           0 :   PostSpecifiedTimingUpdated(mEffect);
     119             : }
     120             : 
     121             : void
     122           0 : AnimationEffectTiming::SetDirection(const PlaybackDirection& aDirection)
     123             : {
     124           0 :   if (mTiming.Direction() == aDirection) {
     125           0 :     return;
     126             :   }
     127             : 
     128           0 :   mTiming.SetDirection(aDirection);
     129             : 
     130           0 :   PostSpecifiedTimingUpdated(mEffect);
     131             : }
     132             : 
     133             : void
     134           0 : AnimationEffectTiming::SetEasing(const nsAString& aEasing, ErrorResult& aRv)
     135             : {
     136             :   Maybe<ComputedTimingFunction> newFunction =
     137           0 :     TimingParams::ParseEasing(aEasing, mDocument, aRv);
     138           0 :   if (aRv.Failed()) {
     139           0 :     return;
     140             :   }
     141             : 
     142           0 :   if (mTiming.TimingFunction() == newFunction) {
     143           0 :     return;
     144             :   }
     145             : 
     146           0 :   mTiming.SetTimingFunction(Move(newFunction));
     147             : 
     148           0 :   PostSpecifiedTimingUpdated(mEffect);
     149             : }
     150             : 
     151             : } // namespace dom
     152             : } // namespace mozilla