Home | History | Annotate | Download | only in rotator 
      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
    124