cc/animation/animation.h

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_ANIMATION_ANIMATION_H_
   6 #define CC_ANIMATION_ANIMATION_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/time/time.h"
  11 #include "cc/base/cc_export.h"
  12
  13 namespace cc {
  14
  15 class AnimationCurve;
  16
  17 // An Animation contains all the state required to play an AnimationCurve.
  18 // Specifically, the affected property, the run state (paused, finished, etc.),
  19 // loop count, last pause time, and the total time spent paused.
  20 class CC_EXPORT Animation {
  21  public:
  22   // Animations begin in the 'WaitingForTargetAvailability' state. An Animation
  23   // waiting for target availibility will run as soon as its target property
  24   // is free (and all the animations animating with it are also able to run).
  25   // When this time arrives, the controller will move the animation into the
  26   // Starting state, and then into the Running state. Running animations may
  27   // toggle between Running and Paused, and may be stopped by moving into either
  28   // the Aborted or Finished states. A Finished animation was allowed to run to
  29   // completion, but an Aborted animation was not.
  30   enum RunState {
  31     WaitingForTargetAvailability = 0,
  32     WaitingForDeletion,
  33     Starting,
  34     Running,
  35     Paused,
  36     Finished,
  37     Aborted,
  38     // This sentinel must be last.
  39     RunStateEnumSize
  40   };
  41
  42   enum TargetProperty {
  43     Transform = 0,
  44     Opacity,
  45     Filter,
  46     ScrollOffset,
  47     BackgroundColor,
  48     // This sentinel must be last.
  49     TargetPropertyEnumSize
  50   };
  51
  52   enum Direction { Normal, Reverse, Alternate, AlternateReverse };
  53
  54   static scoped_ptr<Animation> Create(scoped_ptr<AnimationCurve> curve,
  55                                       int animation_id,
  56                                       int group_id,
  57                                       TargetProperty target_property);
  58
  59   virtual ~Animation();
  60
  61   int id() const { return id_; }
  62   int group() const { return group_; }
  63   TargetProperty target_property() const { return target_property_; }
  64
  65   RunState run_state() const { return run_state_; }
  66   void SetRunState(RunState run_state, base::TimeTicks monotonic_time);
  67
  68   // This is the number of times that the animation will play. If this
  69   // value is zero the animation will not play. If it is negative, then
  70   // the animation will loop indefinitely.
  71   int iterations() const { return iterations_; }
  72   void set_iterations(int n) { iterations_ = n; }
  73
  74   base::TimeTicks start_time() const { return start_time_; }
  75
  76   void set_start_time(base::TimeTicks monotonic_time) {
  77     start_time_ = monotonic_time;
  78   }
  79   bool has_set_start_time() const { return !start_time_.is_null(); }
  80
  81   base::TimeDelta time_offset() const { return time_offset_; }
  82   void set_time_offset(base::TimeDelta monotonic_time) {
  83     time_offset_ = monotonic_time;
  84   }
  85
  86   void Suspend(base::TimeTicks monotonic_time);
  87   void Resume(base::TimeTicks monotonic_time);
  88
  89   Direction direction() { return direction_; }
  90   void set_direction(Direction direction) { direction_ = direction; }
  91
  92   bool IsFinishedAt(base::TimeTicks monotonic_time) const;
  93   bool is_finished() const {
  94     return run_state_ == Finished ||
  95         run_state_ == Aborted ||
  96         run_state_ == WaitingForDeletion;
  97   }
  98
  99   AnimationCurve* curve() { return curve_.get(); }
 100   const AnimationCurve* curve() const { return curve_.get(); }
 101
 102   // If this is true, even if the animation is running, it will not be tickable
 103   // until it is given a start time. This is true for animations running on the
 104   // main thread.
 105   bool needs_synchronized_start_time() const {
 106     return needs_synchronized_start_time_;
 107   }
 108   void set_needs_synchronized_start_time(bool needs_synchronized_start_time) {
 109     needs_synchronized_start_time_ = needs_synchronized_start_time;
 110   }
 111
 112   // This is true for animations running on the main thread when the Finished
 113   // event sent by the corresponding impl animation has been received.
 114   bool received_finished_event() const {
 115     return received_finished_event_;
 116   }
 117   void set_received_finished_event(bool received_finished_event) {
 118     received_finished_event_ = received_finished_event;
 119   }
 120
 121   // Takes the given absolute time, and using the start time and the number
 122   // of iterations, returns the relative time in the current iteration.
 123   double TrimTimeToCurrentIteration(base::TimeTicks monotonic_time) const;
 124
 125   scoped_ptr<Animation> CloneAndInitialize(RunState initial_run_state) const;
 126
 127   bool is_controlling_instance() const { return is_controlling_instance_; }
 128
 129   void PushPropertiesTo(Animation* other) const;
 130
 131   void set_is_impl_only(bool is_impl_only) { is_impl_only_ = is_impl_only; }
 132   bool is_impl_only() const { return is_impl_only_; }
 133
 134   void set_affects_active_observers(bool affects_active_observers) {
 135     affects_active_observers_ = affects_active_observers;
 136   }
 137   bool affects_active_observers() const { return affects_active_observers_; }
 138
 139   void set_affects_pending_observers(bool affects_pending_observers) {
 140     affects_pending_observers_ = affects_pending_observers;
 141   }
 142   bool affects_pending_observers() const { return affects_pending_observers_; }
 143
 144  private:
 145   Animation(scoped_ptr<AnimationCurve> curve,
 146             int animation_id,
 147             int group_id,
 148             TargetProperty target_property);
 149
 150   scoped_ptr<AnimationCurve> curve_;
 151
 152   // IDs are not necessarily unique.
 153   int id_;
 154
 155   // Animations that must be run together are called 'grouped' and have the same
 156   // group id. Grouped animations are guaranteed to start at the same time and
 157   // no other animations may animate any of the group's target properties until
 158   // all animations in the group have finished animating. Note: an active
 159   // animation's group id and target property uniquely identify that animation.
 160   int group_;
 161
 162   TargetProperty target_property_;
 163   RunState run_state_;
 164   int iterations_;
 165   base::TimeTicks start_time_;
 166   Direction direction_;
 167
 168   // The time offset effectively pushes the start of the animation back in time.
 169   // This is used for resuming paused animations -- an animation is added with a
 170   // non-zero time offset, causing the animation to skip ahead to the desired
 171   // point in time.
 172   base::TimeDelta time_offset_;
 173
 174   bool needs_synchronized_start_time_;
 175   bool received_finished_event_;
 176
 177   // When an animation is suspended, it behaves as if it is paused and it also
 178   // ignores all run state changes until it is resumed. This is used for testing
 179   // purposes.
 180   bool suspended_;
 181
 182   // These are used in TrimTimeToCurrentIteration to account for time
 183   // spent while paused. This is not included in AnimationState since it
 184   // there is absolutely no need for clients of this controller to know
 185   // about these values.
 186   base::TimeTicks pause_time_;
 187   base::TimeDelta total_paused_time_;
 188
 189   // Animations lead dual lives. An active animation will be conceptually owned
 190   // by two controllers, one on the impl thread and one on the main. In reality,
 191   // there will be two separate Animation instances for the same animation. They
 192   // will have the same group id and the same target property (these two values
 193   // uniquely identify an animation). The instance on the impl thread is the
 194   // instance that ultimately controls the values of the animating layer and so
 195   // we will refer to it as the 'controlling instance'.
 196   bool is_controlling_instance_;
 197
 198   bool is_impl_only_;
 199
 200   // When pushed from a main-thread controller to a compositor-thread
 201   // controller, an animation will initially only affect pending observers
 202   // (corresponding to layers in the pending tree). Animations that only
 203   // affect pending observers are able to reach the Starting state and tick
 204   // pending observers, but cannot proceed any further and do not tick active
 205   // observers. After activation, such animations affect both kinds of observers
 206   // and are able to proceed past the Starting state. When the removal of
 207   // an animation is pushed from a main-thread controller to a
 208   // compositor-thread controller, this initially only makes the animation
 209   // stop affecting pending observers. After activation, such animations no
 210   // longer affect any observers, and are deleted.
 211   bool affects_active_observers_;
 212   bool affects_pending_observers_;
 213
 214   DISALLOW_COPY_AND_ASSIGN(Animation);
 215 };
 216
 217 }  // namespace cc
 218
 219 #endif  // CC_ANIMATION_ANIMATION_H_