ash/rotator/screen_rotation.cc

   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 "ash/rotator/screen_rotation.h"
   6
   7 #include "base/time/time.h"
   8 #include "ui/compositor/layer.h"
   9 #include "ui/gfx/interpolated_transform.h"
  10 #include "ui/gfx/rect.h"
  11 #include "ui/gfx/transform.h"
  12
  13 namespace ash {
  14
  15 namespace {
  16
  17 const int k90DegreeTransitionDurationMs = 350;
  18 const int k180DegreeTransitionDurationMs = 550;
  19 const int k360DegreeTransitionDurationMs = 750;
  20
  21 base::TimeDelta GetTransitionDuration(int degrees) {
  22   if (degrees == 360)
  23     return base::TimeDelta::FromMilliseconds(k360DegreeTransitionDurationMs);
  24   if (degrees == 180)
  25     return base::TimeDelta::FromMilliseconds(k180DegreeTransitionDurationMs);
  26   if (degrees == 0)
  27     return base::TimeDelta::FromMilliseconds(0);
  28   return base::TimeDelta::FromMilliseconds(k90DegreeTransitionDurationMs);
  29 }
  30
  31 }  // namespace
  32
  33 ScreenRotation::ScreenRotation(int degrees, ui::Layer* layer)
  34     : ui::LayerAnimationElement(LayerAnimationElement::TRANSFORM,
  35                                 GetTransitionDuration(degrees)),
  36       degrees_(degrees) {
  37   InitTransform(layer);
  38 }
  39
  40 ScreenRotation::~ScreenRotation() {
  41 }
  42
  43 void ScreenRotation::InitTransform(ui::Layer* layer) {
  44   // No rotation required, use the identity transform.
  45   if (degrees_ == 0) {
  46     interpolated_transform_.reset(
  47         new ui::InterpolatedConstantTransform(gfx::Transform()));
  48     return;
  49   }
  50
  51   // Use the target transform/bounds in case the layer is already animating.
  52   const gfx::Transform& current_transform = layer->GetTargetTransform();
  53   const gfx::Rect& bounds = layer->GetTargetBounds();
  54
  55   gfx::Point old_pivot;
  56   gfx::Point new_pivot;
  57
  58   int width = bounds.width();
  59   int height = bounds.height();
  60
  61   switch (degrees_) {
  62     case 90:
  63       new_origin_ = new_pivot = gfx::Point(width, 0);
  64       break;
  65     case -90:
  66       new_origin_ = new_pivot = gfx::Point(0, height);
  67       break;
  68     case 180:
  69     case 360:
  70       new_pivot = old_pivot = gfx::Point(width / 2, height / 2);
  71       new_origin_.SetPoint(width, height);
  72       break;
  73   }
  74
  75   // Convert points to world space.
  76   current_transform.TransformPoint(&old_pivot);
  77   current_transform.TransformPoint(&new_pivot);
  78   current_transform.TransformPoint(&new_origin_);
  79
  80   scoped_ptr<ui::InterpolatedTransform> rotation(
  81       new ui::InterpolatedTransformAboutPivot(
  82           old_pivot,
  83           new ui::InterpolatedRotation(0, degrees_)));
  84
  85   scoped_ptr<ui::InterpolatedTransform> translation(
  86       new ui::InterpolatedTranslation(
  87           gfx::Point(0, 0),
  88           gfx::Point(new_pivot.x() - old_pivot.x(),
  89                      new_pivot.y() - old_pivot.y())));
  90
  91   float scale_factor = 0.9f;
  92   scoped_ptr<ui::InterpolatedTransform> scale_down(
  93       new ui::InterpolatedScale(1.0f, scale_factor, 0.0f, 0.5f));
  94
  95   scoped_ptr<ui::InterpolatedTransform> scale_up(
  96       new ui::InterpolatedScale(1.0f, 1.0f / scale_factor, 0.5f, 1.0f));
  97
  98   interpolated_transform_.reset(
  99       new ui::InterpolatedConstantTransform(current_transform));
 100
 101   scale_up->SetChild(scale_down.release());
 102   translation->SetChild(scale_up.release());
 103   rotation->SetChild(translation.release());
 104   interpolated_transform_->SetChild(rotation.release());
 105 }
 106
 107 void ScreenRotation::OnStart(ui::LayerAnimationDelegate* delegate) {
 108 }
 109
 110 bool ScreenRotation::OnProgress(double t,
 111                                 ui::LayerAnimationDelegate* delegate) {
 112   delegate->SetTransformFromAnimation(interpolated_transform_->Interpolate(t));
 113   return true;
 114 }
 115
 116 void ScreenRotation::OnGetTarget(TargetValue* target) const {
 117   target->transform = interpolated_transform_->Interpolate(1.0);
 118 }
 119
 120 void ScreenRotation::OnAbort(ui::LayerAnimationDelegate* delegate) {
 121 }
 122
 123 }  // namespace ash