Animated Rotation

chrome/browser/ui/touch/animation/screen_rotation.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 "chrome/browser/ui/touch/animation/screen_rotation.h"
+
+#include "base/debug/trace_event.h"
+#include "base/message_loop.h"
+#include "base/task.h"
+#include "ui/base/animation/slide_animation.h"
+#include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/interpolated_transform.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/transform.h"
+#include "views/paint_lock.h"
+#include "views/view.h"
+
+namespace {
+const int kDefaultTransitionDurationMs = 350;
+
+} // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+// ScreenRotationListener public:
+//
+
+ScreenRotationListener::~ScreenRotationListener() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ScreenRotation public:
+//
+
+ScreenRotation::ScreenRotation(views::View* view,
+                               ScreenRotationListener* listener,
+                               float old_degrees,
+                               float new_degrees)
+    : view_(view),
+      listener_(listener),
+      old_degrees_(old_degrees),
+      new_degrees_(new_degrees),
+      last_t_(0.0),
+      duration_(kDefaultTransitionDurationMs),
+      animation_started_(false),
+      animation_stopped_(false) {
+  DCHECK(view);
+  DCHECK(listener);
+
+  if (!view->layer()) {
+    Finalize();
+  } else {
+    // Screen rotations are trigged as a result of a call to SetTransform which
+    // causes a paint to be scheduled to occur. At this point, the paint has
+    // been scheduled, but has not yet been started. We will listen for this
+    // paint to be completed before we start animating.
+    view->layer()->AddObserver(this);
+  }
+}
+
+ScreenRotation::~ScreenRotation() {
+  if (view_->layer())
+    view_->layer()->RemoveObserver(this);
+}
+
+void ScreenRotation::SetTarget(float degrees) {
+  if (new_degrees_ == degrees)
+    return;
+
+  new_degrees_ = degrees;
+  Init();
+}
+
+void ScreenRotation::Stop() {
+  animation_.reset();
+  if (view_->layer()) {
+    if (!interpolated_transform_.get()) {
+      // attempt to initialize.
+      Init();
+    }
+    if (interpolated_transform_.get()) {
+      view_->layer()->SetTransform(interpolated_transform_->Interpolate(1.0));
+      view_->layer()->compositor()->SchedulePaint();
+    }
+  }
+  Finalize();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ScreenRotation private:
+//
+
+void ScreenRotation::AnimationProgressed(const ui::Animation* anim) {
+  TRACE_EVENT0("ScreenRotation", "step");
+  last_t_ = static_cast<float>(anim->GetCurrentValue());
+  view_->layer()->SetTransform(interpolated_transform_->Interpolate(last_t_));
+  view_->layer()->compositor()->SchedulePaint();
+}
+
+void ScreenRotation::AnimationEnded(const ui::Animation* anim) {
+  TRACE_EVENT_END0("ScreenRotation", "ScreenRotation");
+  // TODO(vollick) massage matrix so that entries sufficiently close
+  // to 0, 1, or -1 are clamped to these values. The idea is to fight
+  // accumulated numeric error due to successive rotations.
+  ui::Transform xform = view_->layer()->transform();
+  gfx::Point origin;
+  xform.TransformPoint(origin);
+  ui::Transform translation;
+  translation.SetTranslate(new_origin_.x() - origin.x(),
+                           new_origin_.y() - origin.y());
+  xform.ConcatTransform(translation);
+  view_->layer()->SetTransform(xform);
+  view_->layer()->compositor()->SchedulePaint();
+  animation_stopped_ = true;
+}
+
+void ScreenRotation::OnDraw(ui::Layer* layer) {
+  DoPendingWork();
+}
+
+void ScreenRotation::Init() {
+  TRACE_EVENT0("ScreenRotation", "init");
+
+  ui::Transform current_transform = view_->layer()->transform();
+  int degrees = new_degrees_ - old_degrees_;
+  degrees = NormalizeAngle(degrees);
+
+  // No rotation required.
+  if (degrees == 0)
+    return;
+
+  gfx::Point old_pivot;
+  gfx::Point new_pivot;
+  int width = view_->layer()->bounds().width();
+  int height = view_->layer()->bounds().height();
+
+  switch (degrees) {
+    case 90:
+      new_origin_ = new_pivot = gfx::Point(width, 0);
+      new_size_.SetSize(height, width);
+      break;
+    case -90:
+      new_origin_ = new_pivot = gfx::Point(0, height);
+      new_size_.SetSize(height, width);
+      break;
+    case 180:
+      duration_ = 550;
+      new_pivot = old_pivot = gfx::Point(width / 2, height / 2);
+      new_origin_.SetPoint(width, height);
+      new_size_.SetSize(width, height);
+      break;
+  }
+
+  // Convert points to world space.
+  current_transform.TransformPoint(old_pivot);
+  current_transform.TransformPoint(new_pivot);
+  current_transform.TransformPoint(new_origin_);
+
+  scoped_ptr<ui::InterpolatedTransform> rotation(
+      new ui::InterpolatedTransformAboutPivot(
+          old_pivot,
+          new ui::InterpolatedRotation(0, degrees)));
+
+  scoped_ptr<ui::InterpolatedTransform> translation(
+      new ui::InterpolatedTranslation(
+          gfx::Point(0, 0),
+          gfx::Point(new_pivot.x() - old_pivot.x(),
+                     new_pivot.y() - old_pivot.y())));
+
+  float scale_factor = 0.9f;
+  scoped_ptr<ui::InterpolatedTransform> scale_down(
+      new ui::InterpolatedScale(1.0f, scale_factor, 0.0f, 0.5f));
+
+  scoped_ptr<ui::InterpolatedTransform> scale_up(
+      new ui::InterpolatedScale(1.0f, 1.0f / scale_factor, 0.5f, 1.0f));
+
+  scoped_ptr<ui::InterpolatedTransform> transition(
+      new ui::InterpolatedConstantTransform(current_transform));
+
+  scale_up->SetChild(scale_down.release());
+  translation->SetChild(scale_up.release());
+  rotation->SetChild(translation.release());
+  transition->SetChild(rotation.release());
+
+  if (interpolated_transform_.get()) {
+    // We are in the middle of a transition. In this case, we need to create
+    // an interpolated transform that gets us from where we are to the target
+    // transform.
+    ui::Transform target = transition->Interpolate(1.0);
+    interpolated_transform_.reset(
+        new ui::InterpolatedTRSTransform(
+            current_transform, target, last_t_, 1.0));
+  } else {
+    interpolated_transform_.reset(transition.release());
+  }
+}
+
+void ScreenRotation::Start() {
+  TRACE_EVENT_BEGIN0("ScreenRotation", "ScreenRotation");
+  Init();
+  if (interpolated_transform_.get()) {
+    paint_lock_.reset(new views::PaintLock(view_));
+    animation_.reset(new ui::SlideAnimation(this));
+    animation_->SetTweenType(ui::Tween::LINEAR);
+    animation_->SetSlideDuration(duration_);
+    animation_->Show();
+    animation_started_ = true;
+  } else {
+    Finalize();
+  }
+}
+
+void ScreenRotation::Finalize() {
+  ui::Transform final_transform = view_->GetTransform();
+  gfx::Rect final_bounds(0, 0, new_size_.width(), new_size_.height());
+  listener_->OnScreenRotationCompleted(final_transform, final_bounds);
+}
+
+int ScreenRotation::NormalizeAngle(int degrees) {
+  while (degrees <= -180) degrees += 360;
+  while (degrees > 180) degrees -= 360;
+  return degrees;
+}
+
+void ScreenRotation::DoPendingWork() {
+  if (!animation_started_)
+    Start();
+  else if (animation_stopped_) {
+    view_->layer()->RemoveObserver(this);
+    Finalize();
+  }
+}