dom/animation/TimingParams.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 #ifndef mozilla_TimingParams_h
   8 #define mozilla_TimingParams_h
   9
  10 #include "X11UndefineNone.h"
  11 #include "nsPrintfCString.h"
  12 #include "nsStringFwd.h"
  13 #include "nsPrintfCString.h"
  14 #include "mozilla/dom/Nullable.h"
  15 #include "mozilla/dom/UnionTypes.h"  // For OwningUnrestrictedDoubleOrString
  16 #include "mozilla/ComputedTimingFunction.h"
  17 #include "mozilla/Maybe.h"
  18 #include "mozilla/StickyTimeDuration.h"
  19 #include "mozilla/TimeStamp.h"  // for TimeDuration
  20
  21 #include "mozilla/dom/AnimationEffectBinding.h"  // for FillMode
  22                                                  // and PlaybackDirection
  23
  24 #define PROGRESS_TIMELINE_DURATION_MILLISEC 100000
  25
  26 namespace mozilla {
  27
  28 namespace dom {
  29 class UnrestrictedDoubleOrKeyframeEffectOptions;
  30 class UnrestrictedDoubleOrKeyframeAnimationOptions;
  31 }  // namespace dom
  32
  33 struct TimingParams {
  34   TimingParams() = default;
  35
  36   TimingParams(float aDuration, float aDelay, float aIterationCount,
  37                dom::PlaybackDirection aDirection, dom::FillMode aFillMode)
  38       : mIterations(aIterationCount), mDirection(aDirection), mFill(aFillMode) {
  39     mDuration.emplace(StickyTimeDuration::FromMilliseconds(aDuration));
  40     mDelay = TimeDuration::FromMilliseconds(aDelay);
  41     Update();
  42   }
  43
  44   TimingParams(const TimeDuration& aDuration, const TimeDuration& aDelay,
  45                const TimeDuration& aEndDelay, float aIterations,
  46                float aIterationStart, dom::PlaybackDirection aDirection,
  47                dom::FillMode aFillMode,
  48                Maybe<ComputedTimingFunction>&& aFunction)
  49       : mDelay(aDelay),
  50         mEndDelay(aEndDelay),
  51         mIterations(aIterations),
  52         mIterationStart(aIterationStart),
  53         mDirection(aDirection),
  54         mFill(aFillMode),
  55         mFunction(aFunction) {
  56     mDuration.emplace(aDuration);
  57     Update();
  58   }
  59
  60   template <class OptionsType>
  61   static TimingParams FromOptionsType(const OptionsType& aOptions,
  62                                       ErrorResult& aRv);
  63   static TimingParams FromOptionsUnion(
  64       const dom::UnrestrictedDoubleOrKeyframeEffectOptions& aOptions,
  65       ErrorResult& aRv);
  66   static TimingParams FromOptionsUnion(
  67       const dom::UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
  68       ErrorResult& aRv);
  69   static TimingParams FromEffectTiming(const dom::EffectTiming& aEffectTiming,
  70                                        ErrorResult& aRv);
  71   // Returns a copy of |aSource| where each timing property in |aSource| that
  72   // is also specified in |aEffectTiming| is replaced with the value from
  73   // |aEffectTiming|.
  74   //
  75   // If any of the values in |aEffectTiming| are invalid, |aRv.Failed()| will be
  76   // true and an unmodified copy of |aSource| will be returned.
  77   static TimingParams MergeOptionalEffectTiming(
  78       const TimingParams& aSource,
  79       const dom::OptionalEffectTiming& aEffectTiming, ErrorResult& aRv);
  80
  81   // Range-checks and validates an UnrestrictedDoubleOrString or
  82   // OwningUnrestrictedDoubleOrString object and converts to a
  83   // StickyTimeDuration value or Nothing() if aDuration is "auto".
  84   // Caller must check aRv.Failed().
  85   template <class DoubleOrString>
  86   static Maybe<StickyTimeDuration> ParseDuration(DoubleOrString& aDuration,
  87                                                  ErrorResult& aRv) {
  88     Maybe<StickyTimeDuration> result;
  89     if (aDuration.IsUnrestrictedDouble()) {
  90       double durationInMs = aDuration.GetAsUnrestrictedDouble();
  91       if (durationInMs >= 0) {
  92         result.emplace(StickyTimeDuration::FromMilliseconds(durationInMs));
  93       } else {
  94         nsPrintfCString err("Duration (%g) must be nonnegative", durationInMs);
  95         aRv.ThrowTypeError(err);
  96       }
  97     } else if (!aDuration.GetAsString().EqualsLiteral("auto")) {
  98       aRv.ThrowTypeError<dom::MSG_INVALID_DURATION_ERROR>(
  99           NS_ConvertUTF16toUTF8(aDuration.GetAsString()));
 100     }
 101     return result;
 102   }
 103
 104   static void ValidateIterationStart(double aIterationStart, ErrorResult& aRv) {
 105     if (aIterationStart < 0) {
 106       nsPrintfCString err("Iteration start (%g) must not be negative",
 107                           aIterationStart);
 108       aRv.ThrowTypeError(err);
 109     }
 110   }
 111
 112   static void ValidateIterations(double aIterations, ErrorResult& aRv) {
 113     if (IsNaN(aIterations)) {
 114       aRv.ThrowTypeError("Iterations must not be NaN");
 115       return;
 116     }
 117
 118     if (aIterations < 0) {
 119       nsPrintfCString err("Iterations (%g) must not be negative", aIterations);
 120       aRv.ThrowTypeError(err);
 121     }
 122   }
 123
 124   static Maybe<ComputedTimingFunction> ParseEasing(const nsACString& aEasing,
 125                                                    ErrorResult& aRv);
 126
 127   static StickyTimeDuration CalcActiveDuration(
 128       const Maybe<StickyTimeDuration>& aDuration, double aIterations) {
 129     // If either the iteration duration or iteration count is zero,
 130     // Web Animations says that the active duration is zero. This is to
 131     // ensure that the result is defined when the other argument is Infinity.
 132     static const StickyTimeDuration zeroDuration;
 133     if (!aDuration || aDuration->IsZero() || aIterations == 0.0) {
 134       return zeroDuration;
 135     }
 136
 137     return aDuration->MultDouble(aIterations);
 138   }
 139   // Return the duration of the active interval calculated by duration and
 140   // iteration count.
 141   StickyTimeDuration ActiveDuration() const {
 142     MOZ_ASSERT(CalcActiveDuration(mDuration, mIterations) == mActiveDuration,
 143                "Cached value of active duration should be up to date");
 144     return mActiveDuration;
 145   }
 146
 147   StickyTimeDuration EndTime() const {
 148     MOZ_ASSERT(mEndTime == std::max(mDelay + ActiveDuration() + mEndDelay,
 149                                     StickyTimeDuration()),
 150                "Cached value of end time should be up to date");
 151     return mEndTime;
 152   }
 153
 154   bool operator==(const TimingParams& aOther) const;
 155   bool operator!=(const TimingParams& aOther) const {
 156     return !(*this == aOther);
 157   }
 158
 159   void SetDuration(Maybe<StickyTimeDuration>&& aDuration) {
 160     mDuration = std::move(aDuration);
 161     Update();
 162   }
 163   void SetDuration(const Maybe<StickyTimeDuration>& aDuration) {
 164     mDuration = aDuration;
 165     Update();
 166   }
 167   const Maybe<StickyTimeDuration>& Duration() const { return mDuration; }
 168
 169   void SetDelay(const TimeDuration& aDelay) {
 170     mDelay = aDelay;
 171     Update();
 172   }
 173   const TimeDuration& Delay() const { return mDelay; }
 174
 175   void SetEndDelay(const TimeDuration& aEndDelay) {
 176     mEndDelay = aEndDelay;
 177     Update();
 178   }
 179   const TimeDuration& EndDelay() const { return mEndDelay; }
 180
 181   void SetIterations(double aIterations) {
 182     mIterations = aIterations;
 183     Update();
 184   }
 185   double Iterations() const { return mIterations; }
 186
 187   void SetIterationStart(double aIterationStart) {
 188     mIterationStart = aIterationStart;
 189   }
 190   double IterationStart() const { return mIterationStart; }
 191
 192   void SetDirection(dom::PlaybackDirection aDirection) {
 193     mDirection = aDirection;
 194   }
 195   dom::PlaybackDirection Direction() const { return mDirection; }
 196
 197   void SetFill(dom::FillMode aFill) { mFill = aFill; }
 198   dom::FillMode Fill() const { return mFill; }
 199
 200   void SetTimingFunction(Maybe<ComputedTimingFunction>&& aFunction) {
 201     mFunction = std::move(aFunction);
 202   }
 203   const Maybe<ComputedTimingFunction>& TimingFunction() const {
 204     return mFunction;
 205   }
 206
 207   void Normalize();
 208
 209  private:
 210   void Update() {
 211     mActiveDuration = CalcActiveDuration(mDuration, mIterations);
 212
 213     mEndTime =
 214         std::max(mDelay + mActiveDuration + mEndDelay, StickyTimeDuration());
 215   }
 216
 217   // mDuration.isNothing() represents the "auto" value
 218   Maybe<StickyTimeDuration> mDuration;
 219   TimeDuration mDelay;  // Initializes to zero
 220   TimeDuration mEndDelay;
 221   double mIterations = 1.0;  // Can be NaN, negative, +/-Infinity
 222   double mIterationStart = 0.0;
 223   dom::PlaybackDirection mDirection = dom::PlaybackDirection::Normal;
 224   dom::FillMode mFill = dom::FillMode::Auto;
 225   Maybe<ComputedTimingFunction> mFunction;
 226   StickyTimeDuration mActiveDuration = StickyTimeDuration();
 227   StickyTimeDuration mEndTime = StickyTimeDuration();
 228 };
 229
 230 }  // namespace mozilla
 231
 232 #endif  // mozilla_TimingParams_h