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 "cc/base/cc_export.h"
  11
  12 namespace cc {
  13
  14 class AnimationCurve;
  15
  16 // An Animation, contains all the state required to play an AnimationCurve.
  17 // Specifically, the affected property, the run state (paused, finished, etc.),
  18 // loop count, last pause time, and the total time spent paused.
  19 class CC_EXPORT Animation {
  20  public:
  21   // Animations begin in one of the 'waiting' states. Animations waiting for the
  22   // next tick will start the next time the controller animates. Animations
  23   // waiting for target availibility will run as soon as their target property
  24   // is free (and all the animations animating with it are also able to run).
  25   // Animations waiting for their start time to come have be scheduled to run at
  26   // a particular point in time. When this time arrives, the controller will
  27   // move the animations into the Starting state, and then into the Running
  28   // state. Running animations may toggle between Running and Paused, and may be
  29   // stopped by moving into either the Aborted or Finished states. A Finished
  30   // animation was allowed to run to completion, but an Aborted animation was
  31   // not.
  32   enum RunState {
  33     WaitingForNextTick = 0,
  34     WaitingForTargetAvailability,
  35     WaitingForStartTime,
  36     WaitingForDeletion,
  37     Starting,
  38     Running,
  39     Paused,
  40     Finished,
  41     Aborted,
  42     // This sentinel must be last.
  43     RunStateEnumSize
  44   };
  45
  46   enum TargetProperty {
  47     Transform = 0,
  48     Opacity,
  49     // This sentinel must be last.
  50     TargetPropertyEnumSize
  51   };
  52
  53   static scoped_ptr<Animation> Create(scoped_ptr<AnimationCurve> curve,
  54                                       int animation_id,
  55                                       int group_id,
  56                                       TargetProperty target_property);
  57
  58   virtual ~Animation();
  59
  60   int id() const { return id_; }
  61   int group() const { return group_; }
  62   TargetProperty target_property() const { return target_property_; }
  63
  64   RunState run_state() const { return run_state_; }
  65   void SetRunState(RunState run_state, double monotonic_time);
  66
  67   // This is the number of times that the animation will play. If this
  68   // value is zero the animation will not play. If it is negative, then
  69   // the animation will loop indefinitely.
  70   int iterations() const { return iterations_; }
  71   void set_iterations(int n) { iterations_ = n; }
  72
  73   double start_time() const { return start_time_; }
  74   void set_start_time(double monotonic_time) { start_time_ = monotonic_time; }
  75   bool has_set_start_time() const { return !!start_time_; }
  76
  77   double time_offset() const { return time_offset_; }
  78   void set_time_offset(double monotonic_time) { time_offset_ = monotonic_time; }
  79
  80   void Suspend(double monotonic_time);
  81   void Resume(double monotonic_time);
  82
  83   // If alternates_direction is true, on odd numbered iterations we reverse the
  84   // curve.
  85   bool alternates_direction() const { return alternates_direction_; }
  86   void set_alternates_direction(bool alternates) {
  87     alternates_direction_ = alternates;
  88   }
  89
  90   bool IsFinishedAt(double monotonic_time) const;
  91   bool is_finished() const {
  92     return run_state_ == Finished ||
  93         run_state_ == Aborted ||
  94         run_state_ == WaitingForDeletion;
  95   }
  96
  97   AnimationCurve* curve() { return curve_.get(); }
  98   const AnimationCurve* curve() const { return curve_.get(); }
  99
 100   // If this is true, even if the animation is running, it will not be tickable
 101   // until it is given a start time. This is true for animations running on the
 102   // main thread.
 103   bool needs_synchronized_start_time() const {
 104     return needs_synchronized_start_time_;
 105   }
 106   void set_needs_synchronized_start_time(bool needs_synchronized_start_time) {
 107     needs_synchronized_start_time_ = needs_synchronized_start_time;
 108   }
 109
 110   // This is true for animations running on the main thread when the Finished
 111   // event sent by the corresponding impl animation has been received.
 112   bool received_finished_event() const {
 113     return received_finished_event_;
 114   }
 115   void set_received_finished_event(bool received_finished_event) {
 116     received_finished_event_ = received_finished_event;
 117   }
 118
 119   // Takes the given absolute time, and using the start time and the number
 120   // of iterations, returns the relative time in the current iteration.
 121   double TrimTimeToCurrentIteration(double monotonic_time) const;
 122
 123   enum InstanceType {
 124     ControllingInstance = 0,
 125     NonControllingInstance
 126   };
 127
 128   scoped_ptr<Animation> Clone(InstanceType instance_type) const;
 129   scoped_ptr<Animation> CloneAndInitialize(InstanceType instance_type,
 130                                            RunState initial_run_state,
 131                                            double start_time) const;
 132   bool is_controlling_instance() const { return is_controlling_instance_; }
 133
 134   void PushPropertiesTo(Animation* other) const;
 135
 136   void set_is_impl_only(bool is_impl_only) { is_impl_only_ = is_impl_only; }
 137   bool is_impl_only() const { return is_impl_only_; }
 138
 139  private:
 140   Animation(scoped_ptr<AnimationCurve> curve,
 141             int animation_id,
 142             int group_id,
 143             TargetProperty target_property);
 144
 145   scoped_ptr<AnimationCurve> curve_;
 146
 147   // IDs are not necessarily unique.
 148   int id_;
 149
 150   // Animations that must be run together are called 'grouped' and have the same
 151   // group id. Grouped animations are guaranteed to start at the same time and
 152   // no other animations may animate any of the group's target properties until
 153   // all animations in the group have finished animating. Note: an active
 154   // animation's group id and target property uniquely identify that animation.
 155   int group_;
 156
 157   TargetProperty target_property_;
 158   RunState run_state_;
 159   int iterations_;
 160   double start_time_;
 161   bool alternates_direction_;
 162
 163   // The time offset effectively pushes the start of the animation back in time.
 164   // This is used for resuming paused animations -- an animation is added with a
 165   // non-zero time offset, causing the animation to skip ahead to the desired
 166   // point in time.
 167   double time_offset_;
 168
 169   bool needs_synchronized_start_time_;
 170   bool received_finished_event_;
 171
 172   // When an animation is suspended, it behaves as if it is paused and it also
 173   // ignores all run state changes until it is resumed. This is used for testing
 174   // purposes.
 175   bool suspended_;
 176
 177   // These are used in TrimTimeToCurrentIteration to account for time
 178   // spent while paused. This is not included in AnimationState since it
 179   // there is absolutely no need for clients of this controller to know
 180   // about these values.
 181   double pause_time_;
 182   double total_paused_time_;
 183
 184   // Animations lead dual lives. An active animation will be conceptually owned
 185   // by two controllers, one on the impl thread and one on the main. In reality,
 186   // there will be two separate Animation instances for the same animation. They
 187   // will have the same group id and the same target property (these two values
 188   // uniquely identify an animation). The instance on the impl thread is the
 189   // instance that ultimately controls the values of the animating layer and so
 190   // we will refer to it as the 'controlling instance'.
 191   bool is_controlling_instance_;
 192
 193   bool is_impl_only_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(Animation);
 196 };
 197
 198 }  // namespace cc
 199
 200 #endif  // CC_ANIMATION_ANIMATION_H_