Home | History | Annotate | Download | only in input 
      1 // Copyright 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 "cc/input/page_scale_animation.h"
      6 
      7 #include <math.h>
      8 
      9 #include "base/logging.h"
     10 #include "cc/animation/timing_function.h"
     11 #include "ui/gfx/point_f.h"
     12 #include "ui/gfx/rect_f.h"
     13 #include "ui/gfx/vector2d_conversions.h"
     14 
     15 namespace {
     16 
     17 // This takes a viewport-relative vector and returns a vector whose values are
     18 // between 0 and 1, representing the percentage position within the viewport.
     19 gfx::Vector2dF NormalizeFromViewport(gfx::Vector2dF denormalized,
     20                                      gfx::SizeF viewport_size) {
     21   return gfx::ScaleVector2d(denormalized,
     22                             1.f / viewport_size.width(),
     23                             1.f / viewport_size.height());
     24 }
     25 
     26 gfx::Vector2dF DenormalizeToViewport(gfx::Vector2dF normalized,
     27                                      gfx::SizeF viewport_size) {
     28   return gfx::ScaleVector2d(normalized,
     29                             viewport_size.width(),
     30                             viewport_size.height());
     31 }
     32 
     33 gfx::Vector2dF InterpolateBetween(gfx::Vector2dF start,
     34                                   gfx::Vector2dF end,
     35                                   float interp) {
     36   return start + gfx::ScaleVector2d(end - start, interp);
     37 }
     38 
     39 }  // namespace
     40 
     41 namespace cc {
     42 
     43 scoped_ptr<PageScaleAnimation> PageScaleAnimation::Create(
     44     gfx::Vector2dF start_scroll_offset,
     45     float start_page_scale_factor,
     46     gfx::SizeF viewport_size,
     47     gfx::SizeF root_layer_size,
     48     scoped_ptr<TimingFunction> timing_function) {
     49   return make_scoped_ptr(new PageScaleAnimation(start_scroll_offset,
     50                                                 start_page_scale_factor,
     51                                                 viewport_size,
     52                                                 root_layer_size,
     53                                                 timing_function.Pass()));
     54 }
     55 
     56 PageScaleAnimation::PageScaleAnimation(
     57     gfx::Vector2dF start_scroll_offset,
     58     float start_page_scale_factor,
     59     gfx::SizeF viewport_size,
     60     gfx::SizeF root_layer_size,
     61     scoped_ptr<TimingFunction> timing_function)
     62     : start_page_scale_factor_(start_page_scale_factor),
     63       target_page_scale_factor_(0.f),
     64       start_scroll_offset_(start_scroll_offset),
     65       start_anchor_(),
     66       target_anchor_(),
     67       viewport_size_(viewport_size),
     68       root_layer_size_(root_layer_size),
     69       start_time_(-1.0),
     70       duration_(0.0),
     71       timing_function_(timing_function.Pass()) {}
     72 
     73 PageScaleAnimation::~PageScaleAnimation() {}
     74 
     75 void PageScaleAnimation::ZoomTo(gfx::Vector2dF target_scroll_offset,
     76                                 float target_page_scale_factor,
     77                                 double duration) {
     78   target_page_scale_factor_ = target_page_scale_factor;
     79   target_scroll_offset_ = target_scroll_offset;
     80   ClampTargetScrollOffset();
     81   duration_ = duration;
     82 
     83   if (start_page_scale_factor_ == target_page_scale_factor) {
     84     start_anchor_ = start_scroll_offset_;
     85     target_anchor_ = target_scroll_offset;
     86     return;
     87   }
     88 
     89   // For uniform-looking zooming, infer an anchor from the start and target
     90   // viewport rects.
     91   InferTargetAnchorFromScrollOffsets();
     92   start_anchor_ = target_anchor_;
     93 }
     94 
     95 void PageScaleAnimation::ZoomWithAnchor(gfx::Vector2dF anchor,
     96                                         float target_page_scale_factor,
     97                                         double duration) {
     98   start_anchor_ = anchor;
     99   target_page_scale_factor_ = target_page_scale_factor;
    100   duration_ = duration;
    101 
    102   // We start zooming out from the anchor tapped by the user. But if
    103   // the target scale is impossible to attain without hitting the root layer
    104   // edges, then infer an anchor that doesn't collide with the edges.
    105   // We will interpolate between the two anchors during the animation.
    106   InferTargetScrollOffsetFromStartAnchor();
    107   ClampTargetScrollOffset();
    108 
    109   if (start_page_scale_factor_ == target_page_scale_factor_) {
    110     target_anchor_ = start_anchor_;
    111     return;
    112   }
    113   InferTargetAnchorFromScrollOffsets();
    114 }
    115 
    116 void PageScaleAnimation::InferTargetScrollOffsetFromStartAnchor() {
    117   gfx::Vector2dF normalized = NormalizeFromViewport(
    118       start_anchor_ - start_scroll_offset_, StartViewportSize());
    119   target_scroll_offset_ =
    120       start_anchor_ - DenormalizeToViewport(normalized, TargetViewportSize());
    121 }
    122 
    123 void PageScaleAnimation::InferTargetAnchorFromScrollOffsets() {
    124   // The anchor is the point which is at the same normalized relative position
    125   // within both start viewport rect and target viewport rect. For example, a
    126   // zoom-in double-tap to a perfectly centered rect will have normalized
    127   // anchor (0.5, 0.5), while one to a rect touching the bottom-right of the
    128   // screen will have normalized anchor (1.0, 1.0). In other words, it obeys
    129   // the equations:
    130   // anchor = start_size * normalized + start_offset
    131   // anchor = target_size * normalized + target_offset
    132   // where both anchor and normalized begin as unknowns. Solving
    133   // for the normalized, we get the following:
    134   float width_scale =
    135       1.f / (TargetViewportSize().width() - StartViewportSize().width());
    136   float height_scale =
    137       1.f / (TargetViewportSize().height() - StartViewportSize().height());
    138   gfx::Vector2dF normalized = gfx::ScaleVector2d(
    139       start_scroll_offset_ - target_scroll_offset_, width_scale, height_scale);
    140   target_anchor_ =
    141       target_scroll_offset_ + DenormalizeToViewport(normalized,
    142                                                     TargetViewportSize());
    143 }
    144 
    145 void PageScaleAnimation::ClampTargetScrollOffset() {
    146   gfx::Vector2dF max_scroll_offset =
    147       gfx::RectF(root_layer_size_).bottom_right() -
    148       gfx::RectF(TargetViewportSize()).bottom_right();
    149   target_scroll_offset_.SetToMax(gfx::Vector2dF());
    150   target_scroll_offset_.SetToMin(max_scroll_offset);
    151 }
    152 
    153 gfx::SizeF PageScaleAnimation::StartViewportSize() const {
    154   return gfx::ScaleSize(viewport_size_, 1.f / start_page_scale_factor_);
    155 }
    156 
    157 gfx::SizeF PageScaleAnimation::TargetViewportSize() const {
    158   return gfx::ScaleSize(viewport_size_, 1.f / target_page_scale_factor_);
    159 }
    160 
    161 gfx::SizeF PageScaleAnimation::ViewportSizeAt(float interp) const {
    162   return gfx::ScaleSize(viewport_size_, 1.f / PageScaleFactorAt(interp));
    163 }
    164 
    165 bool PageScaleAnimation::IsAnimationStarted() const {
    166   return start_time_ >= 0;
    167 }
    168 
    169 void PageScaleAnimation::StartAnimation(double time) {
    170   DCHECK_GT(0, start_time_);
    171   start_time_ = time;
    172 }
    173 
    174 gfx::Vector2dF PageScaleAnimation::ScrollOffsetAtTime(double time) const {
    175   DCHECK_GE(start_time_, 0);
    176   return ScrollOffsetAt(InterpAtTime(time));
    177 }
    178 
    179 float PageScaleAnimation::PageScaleFactorAtTime(double time) const {
    180   DCHECK_GE(start_time_, 0);
    181   return PageScaleFactorAt(InterpAtTime(time));
    182 }
    183 
    184 bool PageScaleAnimation::IsAnimationCompleteAtTime(double time) const {
    185   DCHECK_GE(start_time_, 0);
    186   return time >= end_time();
    187 }
    188 
    189 float PageScaleAnimation::InterpAtTime(double time) const {
    190   DCHECK_GE(start_time_, 0);
    191   DCHECK_GE(time, start_time_);
    192   if (IsAnimationCompleteAtTime(time))
    193     return 1.f;
    194 
    195   const double normalized_time = (time - start_time_) / duration_;
    196   return timing_function_->GetValue(normalized_time);
    197 }
    198 
    199 gfx::Vector2dF PageScaleAnimation::ScrollOffsetAt(float interp) const {
    200   if (interp <= 0.f)
    201     return start_scroll_offset_;
    202   if (interp >= 1.f)
    203     return target_scroll_offset_;
    204 
    205   return AnchorAt(interp) - ViewportRelativeAnchorAt(interp);
    206 }
    207 
    208 gfx::Vector2dF PageScaleAnimation::AnchorAt(float interp) const {
    209   // Interpolate from start to target anchor in absolute space.
    210   return InterpolateBetween(start_anchor_, target_anchor_, interp);
    211 }
    212 
    213 gfx::Vector2dF PageScaleAnimation::ViewportRelativeAnchorAt(
    214     float interp) const {
    215   // Interpolate from start to target anchor in normalized space.
    216   gfx::Vector2dF start_normalized =
    217       NormalizeFromViewport(start_anchor_ - start_scroll_offset_,
    218                             StartViewportSize());
    219   gfx::Vector2dF target_normalized =
    220       NormalizeFromViewport(target_anchor_ - target_scroll_offset_,
    221                             TargetViewportSize());
    222   gfx::Vector2dF interp_normalized =
    223       InterpolateBetween(start_normalized, target_normalized, interp);
    224 
    225   return DenormalizeToViewport(interp_normalized, ViewportSizeAt(interp));
    226 }
    227 
    228 float PageScaleAnimation::PageScaleFactorAt(float interp) const {
    229   if (interp <= 0.f)
    230     return start_page_scale_factor_;
    231   if (interp >= 1.f)
    232     return target_page_scale_factor_;
    233 
    234   // Linearly interpolate the magnitude in log scale.
    235   float diff = target_page_scale_factor_ / start_page_scale_factor_;
    236   float log_diff = log(diff);
    237   log_diff *= interp;
    238   diff = exp(log_diff);
    239   return start_page_scale_factor_ * diff;
    240 }
    241 
    242 }  // namespace cc
    243