ui/gfx/animation/animation.cc

   1 // Copyright (c) 2011 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 #include "ui/gfx/animation/animation.h"
   6
   7 #include "ui/gfx/animation/animation_container.h"
   8 #include "ui/gfx/animation/animation_delegate.h"
   9 #include "ui/gfx/animation/tween.h"
  10 #include "ui/gfx/geometry/rect.h"
  11
  12 #if defined(OS_WIN)
  13 #include "base/win/windows_version.h"
  14 #endif
  15
  16 namespace gfx {
  17
  18 Animation::Animation(base::TimeDelta timer_interval)
  19     : timer_interval_(timer_interval),
  20       is_animating_(false),
  21       delegate_(NULL) {
  22 }
  23
  24 Animation::~Animation() {
  25   // Don't send out notification from the destructor. Chances are the delegate
  26   // owns us and is being deleted as well.
  27   if (is_animating_)
  28     container_->Stop(this);
  29 }
  30
  31 void Animation::Start() {
  32   if (is_animating_)
  33     return;
  34
  35   if (!container_.get())
  36     container_ = new AnimationContainer();
  37
  38   is_animating_ = true;
  39
  40   container_->Start(this);
  41
  42   AnimationStarted();
  43 }
  44
  45 void Animation::Stop() {
  46   if (!is_animating_)
  47     return;
  48
  49   is_animating_ = false;
  50
  51   // Notify the container first as the delegate may delete us.
  52   container_->Stop(this);
  53
  54   AnimationStopped();
  55
  56   if (delegate_) {
  57     if (ShouldSendCanceledFromStop())
  58       delegate_->AnimationCanceled(this);
  59     else
  60       delegate_->AnimationEnded(this);
  61   }
  62 }
  63
  64 double Animation::CurrentValueBetween(double start, double target) const {
  65   return Tween::DoubleValueBetween(GetCurrentValue(), start, target);
  66 }
  67
  68 int Animation::CurrentValueBetween(int start, int target) const {
  69   return Tween::IntValueBetween(GetCurrentValue(), start, target);
  70 }
  71
  72 gfx::Rect Animation::CurrentValueBetween(const gfx::Rect& start_bounds,
  73                                          const gfx::Rect& target_bounds) const {
  74   return Tween::RectValueBetween(
  75       GetCurrentValue(), start_bounds, target_bounds);
  76 }
  77
  78 void Animation::SetContainer(AnimationContainer* container) {
  79   if (container == container_.get())
  80     return;
  81
  82   if (is_animating_)
  83     container_->Stop(this);
  84
  85   if (container)
  86     container_ = container;
  87   else
  88     container_ = new AnimationContainer();
  89
  90   if (is_animating_)
  91     container_->Start(this);
  92 }
  93
  94 // static
  95 bool Animation::ShouldRenderRichAnimation() {
  96 #if defined(OS_WIN)
  97   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
  98     BOOL result;
  99     // Get "Turn off all unnecessary animations" value.
 100     if (::SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &result, 0)) {
 101       // There seems to be a typo in the MSDN document (as of May 2009):
 102       //   http://msdn.microsoft.com/en-us/library/ms724947(VS.85).aspx
 103       // The document states that the result is TRUE when animations are
 104       // _disabled_, but in fact, it is TRUE when they are _enabled_.
 105       return !!result;
 106     }
 107   }
 108   return !::GetSystemMetrics(SM_REMOTESESSION);
 109 #else
 110   return true;
 111 #endif
 112 }
 113
 114 bool Animation::ShouldSendCanceledFromStop() {
 115   return false;
 116 }
 117
 118 void Animation::SetStartTime(base::TimeTicks start_time) {
 119   start_time_ = start_time;
 120 }
 121
 122 base::TimeDelta Animation::GetTimerInterval() const {
 123   return timer_interval_;
 124 }
 125
 126 }  // namespace gfx