dom/animation/ElementAnimationData.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_ElementAnimationData_h
   8 #define mozilla_ElementAnimationData_h
   9
  10 #include "mozilla/UniquePtr.h"
  11 #include "mozilla/PseudoStyleType.h"
  12
  13 class nsCycleCollectionTraversalCallback;
  14
  15 namespace mozilla {
  16 enum class PseudoStyleType : uint8_t;
  17 class EffectSet;
  18 template <typename Animation>
  19 class AnimationCollection;
  20 template <typename TimelineType>
  21 class TimelineCollection;
  22 namespace dom {
  23 class Element;
  24 class CSSAnimation;
  25 class CSSTransition;
  26 class ProgressTimelineScheduler;
  27 class ScrollTimeline;
  28 class ViewTimeline;
  29 }  // namespace dom
  30 using CSSAnimationCollection = AnimationCollection<dom::CSSAnimation>;
  31 using CSSTransitionCollection = AnimationCollection<dom::CSSTransition>;
  32 using ScrollTimelineCollection = TimelineCollection<dom::ScrollTimeline>;
  33 using ViewTimelineCollection = TimelineCollection<dom::ViewTimeline>;
  34
  35 // The animation data for a given element (and its pseudo-elements).
  36 class ElementAnimationData {
  37   struct PerElementOrPseudoData {
  38     UniquePtr<EffectSet> mEffectSet;
  39     UniquePtr<CSSAnimationCollection> mAnimations;
  40     UniquePtr<CSSTransitionCollection> mTransitions;
  41
  42     // Note: scroll-timeline-name is applied to elements which could be
  43     // scroll containers, or replaced elements. view-timeline-name is applied to
  44     // all elements. However, the named timeline is referenceable in
  45     // animation-timeline by the tree order scope.
  46     // Spec: https://drafts.csswg.org/scroll-animations-1/#timeline-scope.
  47     //
  48     // So it should be fine to create timeline objects only on the elements and
  49     // pseudo elements which support animations.
  50     UniquePtr<ScrollTimelineCollection> mScrollTimelines;
  51     UniquePtr<ViewTimelineCollection> mViewTimelines;
  52
  53     // This is different from |mScrollTimelines|. We use this to schedule all
  54     // scroll-driven animations (which use anonymous/named scroll timelines or
  55     // anonymous/name view timelines) for a specific scroll source (which is the
  56     // element with nsIScrollableFrame).
  57     //
  58     // TimelineCollection owns and manages the named progress timeline generated
  59     // by specifying scroll-timeline-name property and view-timeline-name
  60     // property on this element. However, the anonymous progress timelines (e.g.
  61     // animation-timeline:scroll()) are owned by Animation objects only.
  62     //
  63     // Note:
  64     // 1. For named scroll timelines. The element which specifies
  65     //    scroll-timeline-name is the scroll source. However, for named view
  66     //    timelines, the element which specifies view-timeline-name may not be
  67     //    the scroll source because we use its nearest scroll container as the
  68     //    scroll source.
  69     // 2. For anonymous progress timelines, we don't keep their timeline obejcts
  70     //    in TimelineCollection.
  71     // So, per 1) and 2), we use |mProgressTimelineScheduler| for the scroll
  72     // source element to schedule scroll-driven animations.
  73     UniquePtr<dom::ProgressTimelineScheduler> mProgressTimelineScheduler;
  74
  75     PerElementOrPseudoData();
  76     ~PerElementOrPseudoData();
  77
  78     EffectSet& DoEnsureEffectSet();
  79     CSSTransitionCollection& DoEnsureTransitions(dom::Element&,
  80                                                  PseudoStyleType);
  81     CSSAnimationCollection& DoEnsureAnimations(dom::Element&, PseudoStyleType);
  82     ScrollTimelineCollection& DoEnsureScrollTimelines(dom::Element&,
  83                                                       PseudoStyleType);
  84     ViewTimelineCollection& DoEnsureViewTimelines(dom::Element&,
  85                                                   PseudoStyleType);
  86     dom::ProgressTimelineScheduler& DoEnsureProgressTimelineScheduler(
  87         dom::Element&, PseudoStyleType);
  88
  89     void DoClearEffectSet();
  90     void DoClearTransitions();
  91     void DoClearAnimations();
  92     void DoClearScrollTimelines();
  93     void DoClearViewTimelines();
  94     void DoClearProgressTimelineScheduler();
  95
  96     void Traverse(nsCycleCollectionTraversalCallback&);
  97   };
  98
  99   PerElementOrPseudoData mElementData;
 100
 101   // TODO(emilio): Maybe this should be a hash map eventually, once we allow
 102   // animating all pseudo-elements.
 103   PerElementOrPseudoData mBeforeData;
 104   PerElementOrPseudoData mAfterData;
 105   PerElementOrPseudoData mMarkerData;
 106
 107   const PerElementOrPseudoData& DataFor(PseudoStyleType aType) const {
 108     switch (aType) {
 109       case PseudoStyleType::NotPseudo:
 110         break;
 111       case PseudoStyleType::before:
 112         return mBeforeData;
 113       case PseudoStyleType::after:
 114         return mAfterData;
 115       case PseudoStyleType::marker:
 116         return mMarkerData;
 117       default:
 118         MOZ_ASSERT_UNREACHABLE(
 119             "Should not try to get animation effects for "
 120             "a pseudo other that :before, :after or ::marker");
 121         break;
 122     }
 123     return mElementData;
 124   }
 125
 126   PerElementOrPseudoData& DataFor(PseudoStyleType aType) {
 127     const auto& data =
 128         const_cast<const ElementAnimationData*>(this)->DataFor(aType);
 129     return const_cast<PerElementOrPseudoData&>(data);
 130   }
 131
 132  public:
 133   void Traverse(nsCycleCollectionTraversalCallback&);
 134
 135   void ClearAllAnimationCollections();
 136
 137   EffectSet* GetEffectSetFor(PseudoStyleType aType) const {
 138     return DataFor(aType).mEffectSet.get();
 139   }
 140
 141   void ClearEffectSetFor(PseudoStyleType aType) {
 142     auto& data = DataFor(aType);
 143     if (data.mEffectSet) {
 144       data.DoClearEffectSet();
 145     }
 146   }
 147
 148   EffectSet& EnsureEffectSetFor(PseudoStyleType aType) {
 149     auto& data = DataFor(aType);
 150     if (auto* set = data.mEffectSet.get()) {
 151       return *set;
 152     }
 153     return data.DoEnsureEffectSet();
 154   }
 155
 156   CSSTransitionCollection* GetTransitionCollection(PseudoStyleType aType) {
 157     return DataFor(aType).mTransitions.get();
 158   }
 159
 160   void ClearTransitionCollectionFor(PseudoStyleType aType) {
 161     auto& data = DataFor(aType);
 162     if (data.mTransitions) {
 163       data.DoClearTransitions();
 164     }
 165   }
 166
 167   CSSTransitionCollection& EnsureTransitionCollection(dom::Element& aOwner,
 168                                                       PseudoStyleType aType) {
 169     auto& data = DataFor(aType);
 170     if (auto* collection = data.mTransitions.get()) {
 171       return *collection;
 172     }
 173     return data.DoEnsureTransitions(aOwner, aType);
 174   }
 175
 176   CSSAnimationCollection* GetAnimationCollection(PseudoStyleType aType) {
 177     return DataFor(aType).mAnimations.get();
 178   }
 179
 180   void ClearAnimationCollectionFor(PseudoStyleType aType) {
 181     auto& data = DataFor(aType);
 182     if (data.mAnimations) {
 183       data.DoClearAnimations();
 184     }
 185   }
 186
 187   CSSAnimationCollection& EnsureAnimationCollection(dom::Element& aOwner,
 188                                                     PseudoStyleType aType) {
 189     auto& data = DataFor(aType);
 190     if (auto* collection = data.mAnimations.get()) {
 191       return *collection;
 192     }
 193     return data.DoEnsureAnimations(aOwner, aType);
 194   }
 195
 196   ScrollTimelineCollection* GetScrollTimelineCollection(PseudoStyleType aType) {
 197     return DataFor(aType).mScrollTimelines.get();
 198   }
 199
 200   void ClearScrollTimelineCollectionFor(PseudoStyleType aType) {
 201     auto& data = DataFor(aType);
 202     if (data.mScrollTimelines) {
 203       data.DoClearScrollTimelines();
 204     }
 205   }
 206
 207   ScrollTimelineCollection& EnsureScrollTimelineCollection(
 208       dom::Element& aOwner, PseudoStyleType aType) {
 209     auto& data = DataFor(aType);
 210     if (auto* collection = data.mScrollTimelines.get()) {
 211       return *collection;
 212     }
 213     return data.DoEnsureScrollTimelines(aOwner, aType);
 214   }
 215
 216   ViewTimelineCollection* GetViewTimelineCollection(PseudoStyleType aType) {
 217     return DataFor(aType).mViewTimelines.get();
 218   }
 219
 220   void ClearViewTimelineCollectionFor(PseudoStyleType aType) {
 221     auto& data = DataFor(aType);
 222     if (data.mViewTimelines) {
 223       data.DoClearViewTimelines();
 224     }
 225   }
 226
 227   ViewTimelineCollection& EnsureViewTimelineCollection(dom::Element& aOwner,
 228                                                        PseudoStyleType aType) {
 229     auto& data = DataFor(aType);
 230     if (auto* collection = data.mViewTimelines.get()) {
 231       return *collection;
 232     }
 233     return data.DoEnsureViewTimelines(aOwner, aType);
 234   }
 235
 236   dom::ProgressTimelineScheduler* GetProgressTimelineScheduler(
 237       PseudoStyleType aType) {
 238     return DataFor(aType).mProgressTimelineScheduler.get();
 239   }
 240
 241   void ClearProgressTimelineScheduler(PseudoStyleType aType) {
 242     auto& data = DataFor(aType);
 243     if (data.mProgressTimelineScheduler) {
 244       data.DoClearProgressTimelineScheduler();
 245     }
 246   }
 247
 248   dom::ProgressTimelineScheduler& EnsureProgressTimelineScheduler(
 249       dom::Element& aOwner, PseudoStyleType aType) {
 250     auto& data = DataFor(aType);
 251     if (auto* collection = data.mProgressTimelineScheduler.get()) {
 252       return *collection;
 253     }
 254     return data.DoEnsureProgressTimelineScheduler(aOwner, aType);
 255   }
 256
 257   ElementAnimationData() = default;
 258 };
 259
 260 }  // namespace mozilla
 261
 262 #endif