Home | History | Annotate | Download | only in input 
      1 // Copyright 2011 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 #ifndef CC_INPUT_PAGE_SCALE_ANIMATION_H_
      6 #define CC_INPUT_PAGE_SCALE_ANIMATION_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "ui/gfx/size.h"
     11 #include "ui/gfx/vector2d_f.h"
     12 
     13 namespace cc {
     14 class TimingFunction;
     15 
     16 // A small helper class that does the math for zoom animations, primarily for
     17 // double-tap zoom. Initialize it with starting and ending scroll/page scale
     18 // positions and an animation length time, then call ...AtTime() at every frame
     19 // to obtain the current interpolated position. The supplied timing function
     20 // is used to ease the animation.
     21 //
     22 // All sizes and vectors in this class's public methods are in the root scroll
     23 // layer's coordinate space.
     24 class PageScaleAnimation {
     25  public:
     26   // Construct with the state at the beginning of the animation.
     27   static scoped_ptr<PageScaleAnimation> Create(
     28       gfx::Vector2dF start_scroll_offset,
     29       float start_page_scale_factor,
     30       gfx::SizeF viewport_size,
     31       gfx::SizeF root_layer_size,
     32       scoped_ptr<TimingFunction> timing_function);
     33 
     34   ~PageScaleAnimation();
     35 
     36   // The following methods initialize the animation. Call one of them
     37   // immediately after construction to set the final scroll and page scale.
     38 
     39   // Zoom while explicitly specifying the top-left scroll position.
     40   void ZoomTo(gfx::Vector2dF target_scroll_offset,
     41               float target_page_scale_factor,
     42               double duration);
     43 
     44   // Zoom based on a specified anchor. The animator will attempt to keep it
     45   // at the same position on the physical display throughout the animation,
     46   // unless the edges of the root layer are hit. The anchor is specified
     47   // as an offset from the content layer.
     48   void ZoomWithAnchor(gfx::Vector2dF anchor,
     49                       float target_page_scale_factor,
     50                       double duration);
     51 
     52   // These should be called before the first frame of animation to initialize
     53   // the start time. StartAnimation should only be called once after creation.
     54   bool IsAnimationStarted() const;
     55   void StartAnimation(double time);
     56 
     57   // Call these functions while the animation is in progress to output the
     58   // current state.
     59   gfx::Vector2dF ScrollOffsetAtTime(double time) const;
     60   float PageScaleFactorAtTime(double time) const;
     61   bool IsAnimationCompleteAtTime(double time) const;
     62 
     63   // The following methods return state which is invariant throughout the
     64   // course of the animation.
     65   double start_time() const { return start_time_; }
     66   double duration() const { return duration_; }
     67   double end_time() const { return start_time_ + duration_; }
     68   gfx::Vector2dF target_scroll_offset() const { return target_scroll_offset_; }
     69   float target_page_scale_factor() const { return target_page_scale_factor_; }
     70 
     71  protected:
     72   PageScaleAnimation(gfx::Vector2dF start_scroll_offset,
     73                      float start_page_scale_factor,
     74                      gfx::SizeF viewport_size,
     75                      gfx::SizeF root_layer_size,
     76                      scoped_ptr<TimingFunction> timing_function);
     77 
     78  private:
     79   void ClampTargetScrollOffset();
     80   void InferTargetScrollOffsetFromStartAnchor();
     81   void InferTargetAnchorFromScrollOffsets();
     82 
     83   gfx::SizeF StartViewportSize() const;
     84   gfx::SizeF TargetViewportSize() const;
     85   float InterpAtTime(double time) const;
     86   gfx::SizeF ViewportSizeAt(float interp) const;
     87   gfx::Vector2dF ScrollOffsetAt(float interp) const;
     88   gfx::Vector2dF AnchorAt(float interp) const;
     89   gfx::Vector2dF ViewportRelativeAnchorAt(float interp) const;
     90   float PageScaleFactorAt(float interp) const;
     91 
     92   float start_page_scale_factor_;
     93   float target_page_scale_factor_;
     94   gfx::Vector2dF start_scroll_offset_;
     95   gfx::Vector2dF target_scroll_offset_;
     96 
     97   gfx::Vector2dF start_anchor_;
     98   gfx::Vector2dF target_anchor_;
     99 
    100   gfx::SizeF viewport_size_;
    101   gfx::SizeF root_layer_size_;
    102 
    103   double start_time_;
    104   double duration_;
    105 
    106   scoped_ptr<TimingFunction> timing_function_;
    107 
    108   DISALLOW_COPY_AND_ASSIGN(PageScaleAnimation);
    109 };
    110 
    111 }  // namespace cc
    112 
    113 #endif  // CC_INPUT_PAGE_SCALE_ANIMATION_H_
    114