Home | History | Annotate | Download | only in animation 
      1 // Copyright (c) 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 #include "ui/views/animation/bounds_animator.h"
      6 
      7 #include "base/memory/scoped_ptr.h"
      8 #include "ui/gfx/animation/animation_container.h"
      9 #include "ui/gfx/animation/slide_animation.h"
     10 #include "ui/views/animation/bounds_animator_observer.h"
     11 #include "ui/views/view.h"
     12 
     13 // Duration in milliseconds for animations.
     14 static const int kDefaultAnimationDuration = 200;
     15 
     16 using gfx::Animation;
     17 using gfx::AnimationContainer;
     18 using gfx::SlideAnimation;
     19 using gfx::Tween;
     20 
     21 namespace views {
     22 
     23 BoundsAnimator::BoundsAnimator(View* parent)
     24     : parent_(parent),
     25       container_(new AnimationContainer()),
     26       animation_duration_ms_(kDefaultAnimationDuration),
     27       tween_type_(Tween::EASE_OUT) {
     28   container_->set_observer(this);
     29 }
     30 
     31 BoundsAnimator::~BoundsAnimator() {
     32   // Reset the delegate so that we don't attempt to notify our observer from
     33   // the destructor.
     34   container_->set_observer(NULL);
     35 
     36   // Delete all the animations, but don't remove any child views. We assume the
     37   // view owns us and is going to be deleted anyway.
     38   for (ViewToDataMap::iterator i = data_.begin(); i != data_.end(); ++i)
     39     CleanupData(false, &(i->second), i->first);
     40 }
     41 
     42 void BoundsAnimator::AnimateViewTo(View* view, const gfx::Rect& target) {
     43   DCHECK(view);
     44   DCHECK_EQ(view->parent(), parent_);
     45 
     46   Data existing_data;
     47 
     48   if (IsAnimating(view)) {
     49     // Don't immediatly delete the animation, that might trigger a callback from
     50     // the animationcontainer.
     51     existing_data = data_[view];
     52 
     53     RemoveFromMaps(view);
     54   }
     55 
     56   // NOTE: we don't check if the view is already at the target location. Doing
     57   // so leads to odd cases where no animations may be present after invoking
     58   // AnimateViewTo. AnimationProgressed does nothing when the bounds of the
     59   // view don't change.
     60 
     61   Data& data = data_[view];
     62   data.start_bounds = view->bounds();
     63   data.target_bounds = target;
     64   data.animation = CreateAnimation();
     65 
     66   animation_to_view_[data.animation] = view;
     67 
     68   data.animation->Show();
     69 
     70   CleanupData(true, &existing_data, NULL);
     71 }
     72 
     73 void BoundsAnimator::SetTargetBounds(View* view, const gfx::Rect& target) {
     74   if (!IsAnimating(view)) {
     75     AnimateViewTo(view, target);
     76     return;
     77   }
     78 
     79   data_[view].target_bounds = target;
     80 }
     81 
     82 gfx::Rect BoundsAnimator::GetTargetBounds(View* view) {
     83   if (!IsAnimating(view))
     84     return view->bounds();
     85   return data_[view].target_bounds;
     86 }
     87 
     88 void BoundsAnimator::SetAnimationForView(View* view,
     89                                          SlideAnimation* animation) {
     90   DCHECK(animation);
     91 
     92   scoped_ptr<SlideAnimation> animation_wrapper(animation);
     93 
     94   if (!IsAnimating(view))
     95     return;
     96 
     97   // We delay deleting the animation until the end so that we don't prematurely
     98   // send out notification that we're done.
     99   scoped_ptr<Animation> old_animation(ResetAnimationForView(view));
    100 
    101   data_[view].animation = animation_wrapper.release();
    102   animation_to_view_[animation] = view;
    103 
    104   animation->set_delegate(this);
    105   animation->SetContainer(container_.get());
    106   animation->Show();
    107 }
    108 
    109 const SlideAnimation* BoundsAnimator::GetAnimationForView(View* view) {
    110   return !IsAnimating(view) ? NULL : data_[view].animation;
    111 }
    112 
    113 void BoundsAnimator::SetAnimationDelegate(View* view,
    114                                           AnimationDelegate* delegate,
    115                                           bool delete_when_done) {
    116   DCHECK(IsAnimating(view));
    117 
    118   data_[view].delegate = delegate;
    119   data_[view].delete_delegate_when_done = delete_when_done;
    120 }
    121 
    122 void BoundsAnimator::StopAnimatingView(View* view) {
    123   if (!IsAnimating(view))
    124     return;
    125 
    126   data_[view].animation->Stop();
    127 }
    128 
    129 bool BoundsAnimator::IsAnimating(View* view) const {
    130   return data_.find(view) != data_.end();
    131 }
    132 
    133 bool BoundsAnimator::IsAnimating() const {
    134   return !data_.empty();
    135 }
    136 
    137 void BoundsAnimator::Cancel() {
    138   if (data_.empty())
    139     return;
    140 
    141   while (!data_.empty())
    142     data_.begin()->second.animation->Stop();
    143 
    144   // Invoke AnimationContainerProgressed to force a repaint and notify delegate.
    145   AnimationContainerProgressed(container_.get());
    146 }
    147 
    148 void BoundsAnimator::SetAnimationDuration(int duration_ms) {
    149   animation_duration_ms_ = duration_ms;
    150 }
    151 
    152 void BoundsAnimator::AddObserver(BoundsAnimatorObserver* observer) {
    153   observers_.AddObserver(observer);
    154 }
    155 
    156 void BoundsAnimator::RemoveObserver(BoundsAnimatorObserver* observer) {
    157   observers_.RemoveObserver(observer);
    158 }
    159 
    160 SlideAnimation* BoundsAnimator::CreateAnimation() {
    161   SlideAnimation* animation = new SlideAnimation(this);
    162   animation->SetContainer(container_.get());
    163   animation->SetSlideDuration(animation_duration_ms_);
    164   animation->SetTweenType(tween_type_);
    165   return animation;
    166 }
    167 
    168 void BoundsAnimator::RemoveFromMaps(View* view) {
    169   DCHECK(data_.count(view) > 0);
    170   DCHECK(animation_to_view_.count(data_[view].animation) > 0);
    171 
    172   animation_to_view_.erase(data_[view].animation);
    173   data_.erase(view);
    174 }
    175 
    176 void BoundsAnimator::CleanupData(bool send_cancel, Data* data, View* view) {
    177   if (send_cancel && data->delegate)
    178     data->delegate->AnimationCanceled(data->animation);
    179 
    180   if (data->delete_delegate_when_done) {
    181     delete static_cast<OwnedAnimationDelegate*>(data->delegate);
    182     data->delegate = NULL;
    183   }
    184 
    185   if (data->animation) {
    186     data->animation->set_delegate(NULL);
    187     delete data->animation;
    188     data->animation = NULL;
    189   }
    190 }
    191 
    192 Animation* BoundsAnimator::ResetAnimationForView(View* view) {
    193   if (!IsAnimating(view))
    194     return NULL;
    195 
    196   Animation* old_animation = data_[view].animation;
    197   animation_to_view_.erase(old_animation);
    198   data_[view].animation = NULL;
    199   // Reset the delegate so that we don't attempt any processing when the
    200   // animation calls us back.
    201   old_animation->set_delegate(NULL);
    202   return old_animation;
    203 }
    204 
    205 void BoundsAnimator::AnimationEndedOrCanceled(const Animation* animation,
    206                                               AnimationEndType type) {
    207   DCHECK(animation_to_view_.find(animation) != animation_to_view_.end());
    208 
    209   View* view = animation_to_view_[animation];
    210   DCHECK(view);
    211 
    212   // Make a copy of the data as Remove empties out the maps.
    213   Data data = data_[view];
    214 
    215   RemoveFromMaps(view);
    216 
    217   if (data.delegate) {
    218     if (type == ANIMATION_ENDED) {
    219       data.delegate->AnimationEnded(animation);
    220     } else {
    221       DCHECK_EQ(ANIMATION_CANCELED, type);
    222       data.delegate->AnimationCanceled(animation);
    223     }
    224   }
    225 
    226   CleanupData(false, &data, view);
    227 }
    228 
    229 void BoundsAnimator::AnimationProgressed(const Animation* animation) {
    230   DCHECK(animation_to_view_.find(animation) != animation_to_view_.end());
    231 
    232   View* view = animation_to_view_[animation];
    233   DCHECK(view);
    234   const Data& data = data_[view];
    235   gfx::Rect new_bounds =
    236       animation->CurrentValueBetween(data.start_bounds, data.target_bounds);
    237   if (new_bounds != view->bounds()) {
    238     gfx::Rect total_bounds = gfx::UnionRects(new_bounds, view->bounds());
    239 
    240     // Build up the region to repaint in repaint_bounds_. We'll do the repaint
    241     // when all animations complete (in AnimationContainerProgressed).
    242     repaint_bounds_.Union(total_bounds);
    243 
    244     view->SetBoundsRect(new_bounds);
    245   }
    246 
    247   if (data.delegate)
    248     data.delegate->AnimationProgressed(animation);
    249 }
    250 
    251 void BoundsAnimator::AnimationEnded(const Animation* animation) {
    252   AnimationEndedOrCanceled(animation, ANIMATION_ENDED);
    253 }
    254 
    255 void BoundsAnimator::AnimationCanceled(const Animation* animation) {
    256   AnimationEndedOrCanceled(animation, ANIMATION_CANCELED);
    257 }
    258 
    259 void BoundsAnimator::AnimationContainerProgressed(
    260     AnimationContainer* container) {
    261   if (!repaint_bounds_.IsEmpty()) {
    262     // Adjust for rtl.
    263     repaint_bounds_.set_x(parent_->GetMirroredXWithWidthInView(
    264         repaint_bounds_.x(), repaint_bounds_.width()));
    265     parent_->SchedulePaintInRect(repaint_bounds_);
    266     repaint_bounds_.SetRect(0, 0, 0, 0);
    267   }
    268 
    269   FOR_EACH_OBSERVER(BoundsAnimatorObserver,
    270                     observers_,
    271                     OnBoundsAnimatorProgressed(this));
    272 
    273   if (!IsAnimating()) {
    274     // Notify here rather than from AnimationXXX to avoid deleting the animation
    275     // while the animation is calling us.
    276     FOR_EACH_OBSERVER(BoundsAnimatorObserver,
    277                       observers_,
    278                       OnBoundsAnimatorDone(this));
    279   }
    280 }
    281 
    282 void BoundsAnimator::AnimationContainerEmpty(AnimationContainer* container) {
    283 }
    284 
    285 }  // namespace views
    286