Implicit animations through Layer.

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "ui/base/animation/animation.h"
+#include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/point3.h"
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : type_(LAYER_HAS_TEXTURE),
       compositor_(compositor),
       parent_(NULL),
       visible_(true),
@@ skipping 58 matching lines @@
 }
 
 bool Layer::Contains(const Layer* other) const {
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
+void Layer::SetAnimation(Animation* animation) {
+  if (animation) {
+    if (!animator_.get())
+      animator_.reset(new LayerAnimator(this));
+    animation->Start();
+    animator_->SetAnimation(animation);
+  } else {
+    animator_.reset();
+  }
+}
+
 void Layer::SetTransform(const ui::Transform& transform) {
-  transform_ = transform;
-
-  if (parent() && fills_bounds_opaquely_)
-    parent()->RecomputeHole();
+  StopAnimatingIfNecessary(LayerAnimator::TRANSFORM);
+  if (animator_.get() && animator_->IsRunning()) {
+    animator_->AnimateTransform(transform);
+    return;
+  }
+  SetTransformImmediately(transform);
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
-  bounds_ = bounds;
+  StopAnimatingIfNecessary(LayerAnimator::LOCATION);
+  if (animator_.get() && animator_->IsRunning() &&
+      bounds.size() == bounds_.size()) {
+    animator_->AnimateToPoint(bounds.origin());
+    return;
+  }
+  SetBoundsImmediately(bounds);
+}
 
-  if (parent() && fills_bounds_opaquely_)
-    parent()->RecomputeHole();
+void Layer::SetOpacity(float opacity) {
+  StopAnimatingIfNecessary(LayerAnimator::OPACITY);
+  if (animator_.get() && animator_->IsRunning()) {
+    animator_->AnimateOpacity(opacity);
+    return;
+  }
+  SetOpacityImmediately(opacity);
 }
 
 void Layer::SetVisible(bool visible) {
   visible_ = visible;
   if (!visible_)
     DropTextures();
 }
 
 bool Layer::ShouldDraw() {
   return type_ == LAYER_HAS_TEXTURE && GetCombinedOpacity() > 0.0f &&
@@ skipping 117 matching lines @@
 
 void Layer::DrawTree() {
   if (!visible_)
     return;
 
   Draw();
   for (size_t i = 0; i < children_.size(); ++i)
     children_.at(i)->DrawTree();
 }
 
-void Layer::SetOpacity(float alpha) {
-  bool was_opaque = GetCombinedOpacity() == 1.0f;
-  opacity_ = alpha;
-  bool is_opaque = GetCombinedOpacity() == 1.0f;
-
-  // If our opacity has changed we need to recompute our hole, our parent's hole
-  // and the holes of all our descendants.
-  if (was_opaque != is_opaque) {
-    if (parent_)
-      parent_->RecomputeHole();
-    std::queue<Layer*> to_process;
-    to_process.push(this);
-    while (!to_process.empty()) {
-      Layer* current = to_process.front();
-      to_process.pop();
-      current->RecomputeHole();
-      for (size_t i = 0; i < current->children_.size(); ++i)
-        to_process.push(current->children_.at(i));
-    }
-  }
-}
-
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
   return opacity;
 }
 
@@ skipping 74 matching lines @@
   const Layer* p = this;
   for (; p && p != ancestor; p = p->parent()) {
     if (p->transform().HasChange())
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
+void Layer::StopAnimatingIfNecessary(
+    LayerAnimator::AnimationProperty property) {
+  if (!animator_.get() || !animator_->IsRunning() ||
+      !animator_->got_initial_tick()) {
+    return;
+  }
+
+  if (property != LayerAnimator::LOCATION &&
+      animator_->IsAnimating(LayerAnimator::LOCATION)) {
+    SetBoundsImmediately(
+        gfx::Rect(animator_->GetTargetPoint(), bounds_.size()));
+  }
+  if (property != LayerAnimator::OPACITY &&
+      animator_->IsAnimating(LayerAnimator::OPACITY)) {
+    SetOpacityImmediately(animator_->GetTargetOpacity());
+  }
+  if (property != LayerAnimator::TRANSFORM &&
+      animator_->IsAnimating(LayerAnimator::TRANSFORM)) {
+    SetTransformImmediately(animator_->GetTargetTransform());
+  }
+  animator_.reset();
+}
+
+void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
+  bounds_ = bounds;
+
+  if (parent() && fills_bounds_opaquely_)
+    parent()->RecomputeHole();
+}
+
+void Layer::SetTransformImmediately(const ui::Transform& transform) {
+  transform_ = transform;
+
+  if (parent() && fills_bounds_opaquely_)
+    parent()->RecomputeHole();
+}
+
+void Layer::SetOpacityImmediately(float opacity) {
+  bool was_opaque = GetCombinedOpacity() == 1.0f;
+  opacity_ = opacity;
+  bool is_opaque = GetCombinedOpacity() == 1.0f;
+
+  // If our opacity has changed we need to recompute our hole, our parent's hole
+  // and the holes of all our descendants.
+  if (was_opaque != is_opaque) {
+    if (parent_)
+      parent_->RecomputeHole();
+    std::queue<Layer*> to_process;
+    to_process.push(this);
+    while (!to_process.empty()) {
+      Layer* current = to_process.front();
+      to_process.pop();
+      current->RecomputeHole();
+      for (size_t i = 0; i < current->children_.size(); ++i)
+        to_process.push(current->children_.at(i));
+    }
+  }
+}
+
+void Layer::SetBoundsFromAnimator(const gfx::Rect& bounds) {
+  SetBoundsImmediately(bounds);
+}
+
+void Layer::SetTransformFromAnimator(const Transform& transform) {
+  SetTransformImmediately(transform);
+}
+
+void Layer::SetOpacityFromAnimator(float opacity) {
+  SetOpacityImmediately(opacity);
+}
+
 }  // namespace ui