Home | History | Annotate | Download | only in input
      1 // Copyright 2013 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/top_controls_manager.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/logging.h"
     10 #include "cc/animation/keyframed_animation_curve.h"
     11 #include "cc/animation/timing_function.h"
     12 #include "cc/input/top_controls_manager_client.h"
     13 #include "cc/output/begin_frame_args.h"
     14 #include "cc/trees/layer_tree_impl.h"
     15 #include "ui/gfx/frame_time.h"
     16 #include "ui/gfx/transform.h"
     17 #include "ui/gfx/vector2d_f.h"
     18 
     19 namespace cc {
     20 namespace {
     21 // These constants were chosen empirically for their visually pleasant behavior.
     22 // Contact tedchoc (at) chromium.org for questions about changing these values.
     23 const int64 kShowHideMaxDurationMs = 200;
     24 }
     25 
     26 // static
     27 scoped_ptr<TopControlsManager> TopControlsManager::Create(
     28     TopControlsManagerClient* client,
     29     float top_controls_height,
     30     float top_controls_show_threshold,
     31     float top_controls_hide_threshold) {
     32   return make_scoped_ptr(new TopControlsManager(client,
     33                                                 top_controls_height,
     34                                                 top_controls_show_threshold,
     35                                                 top_controls_hide_threshold));
     36 }
     37 
     38 TopControlsManager::TopControlsManager(TopControlsManagerClient* client,
     39                                        float top_controls_height,
     40                                        float top_controls_show_threshold,
     41                                        float top_controls_hide_threshold)
     42     : client_(client),
     43       animation_direction_(NO_ANIMATION),
     44       permitted_state_(BOTH),
     45       top_controls_height_(top_controls_height),
     46       current_scroll_delta_(0.f),
     47       controls_scroll_begin_offset_(0.f),
     48       top_controls_show_height_(
     49           top_controls_height * top_controls_hide_threshold),
     50       top_controls_hide_height_(
     51           top_controls_height * (1.f - top_controls_show_threshold)),
     52       pinch_gesture_active_(false) {
     53   CHECK(client_);
     54 }
     55 
     56 TopControlsManager::~TopControlsManager() {
     57 }
     58 
     59 float TopControlsManager::ControlsTopOffset() {
     60   return client_->ControlsTopOffset();
     61 }
     62 
     63 float TopControlsManager::ContentTopOffset() {
     64   return client_->ControlsTopOffset() + top_controls_height_;
     65 }
     66 
     67 void TopControlsManager::UpdateTopControlsState(TopControlsState constraints,
     68                                                 TopControlsState current,
     69                                                 bool animate) {
     70   DCHECK(!(constraints == SHOWN && current == HIDDEN));
     71   DCHECK(!(constraints == HIDDEN && current == SHOWN));
     72 
     73   permitted_state_ = constraints;
     74 
     75   // Don't do anything if it doesn't matter which state the controls are in.
     76   if (constraints == BOTH && current == BOTH)
     77     return;
     78 
     79   // Don't do anything if there is no change in offset.
     80   float final_controls_position = 0.f;
     81   if (constraints == HIDDEN || current == HIDDEN) {
     82     final_controls_position = -top_controls_height_;
     83   }
     84   if (final_controls_position == client_->ControlsTopOffset()) {
     85     return;
     86   }
     87 
     88   AnimationDirection animation_direction = SHOWING_CONTROLS;
     89   if (constraints == HIDDEN || current == HIDDEN)
     90     animation_direction = HIDING_CONTROLS;
     91   ResetAnimations();
     92   if (animate) {
     93     SetupAnimation(animation_direction);
     94   } else {
     95     client_->SetControlsTopOffset(final_controls_position);
     96   }
     97   client_->DidChangeTopControlsPosition();
     98 }
     99 
    100 void TopControlsManager::ScrollBegin() {
    101   DCHECK(!pinch_gesture_active_);
    102   ResetAnimations();
    103   current_scroll_delta_ = 0.f;
    104   controls_scroll_begin_offset_ = client_->ControlsTopOffset();
    105 }
    106 
    107 gfx::Vector2dF TopControlsManager::ScrollBy(
    108     const gfx::Vector2dF& pending_delta) {
    109   if (pinch_gesture_active_)
    110     return pending_delta;
    111 
    112   if (permitted_state_ == SHOWN && pending_delta.y() > 0)
    113     return pending_delta;
    114   else if (permitted_state_ == HIDDEN && pending_delta.y() < 0)
    115     return pending_delta;
    116 
    117   current_scroll_delta_ += pending_delta.y();
    118 
    119   float old_offset = client_->ControlsTopOffset();
    120   SetControlsTopOffset(controls_scroll_begin_offset_ - current_scroll_delta_);
    121 
    122   // If the controls are fully visible, treat the current position as the
    123   // new baseline even if the gesture didn't end.
    124   if (client_->ControlsTopOffset() == 0.f) {
    125     current_scroll_delta_ = 0.f;
    126     controls_scroll_begin_offset_ = 0.f;
    127   }
    128 
    129   ResetAnimations();
    130 
    131   gfx::Vector2dF applied_delta(0.f, old_offset - client_->ControlsTopOffset());
    132   return pending_delta - applied_delta;
    133 }
    134 
    135 void TopControlsManager::ScrollEnd() {
    136   DCHECK(!pinch_gesture_active_);
    137   StartAnimationIfNecessary();
    138 }
    139 
    140 void TopControlsManager::PinchBegin() {
    141   DCHECK(!pinch_gesture_active_);
    142   pinch_gesture_active_ = true;
    143   StartAnimationIfNecessary();
    144 }
    145 
    146 void TopControlsManager::PinchEnd() {
    147   DCHECK(pinch_gesture_active_);
    148   // Pinch{Begin,End} will always occur within the scope of Scroll{Begin,End},
    149   // so return to a state expected by the remaining scroll sequence.
    150   pinch_gesture_active_ = false;
    151   ScrollBegin();
    152 }
    153 
    154 void TopControlsManager::SetControlsTopOffset(float controls_top_offset) {
    155   controls_top_offset = std::max(controls_top_offset, -top_controls_height_);
    156   controls_top_offset = std::min(controls_top_offset, 0.f);
    157 
    158   if (client_->ControlsTopOffset() == controls_top_offset)
    159     return;
    160 
    161   client_->SetControlsTopOffset(controls_top_offset);
    162 
    163   client_->DidChangeTopControlsPosition();
    164 }
    165 
    166 gfx::Vector2dF TopControlsManager::Animate(base::TimeTicks monotonic_time) {
    167   if (!top_controls_animation_ || !client_->HaveRootScrollLayer())
    168     return gfx::Vector2dF();
    169 
    170   double time = (monotonic_time - base::TimeTicks()).InMillisecondsF();
    171 
    172   float old_offset = client_->ControlsTopOffset();
    173   SetControlsTopOffset(top_controls_animation_->GetValue(time));
    174 
    175   if (IsAnimationCompleteAtTime(monotonic_time))
    176     ResetAnimations();
    177 
    178   gfx::Vector2dF scroll_delta(0.f, client_->ControlsTopOffset() - old_offset);
    179   return scroll_delta;
    180 }
    181 
    182 void TopControlsManager::ResetAnimations() {
    183   if (top_controls_animation_)
    184     top_controls_animation_.reset();
    185 
    186   animation_direction_ = NO_ANIMATION;
    187 }
    188 
    189 void TopControlsManager::SetupAnimation(AnimationDirection direction) {
    190   DCHECK(direction != NO_ANIMATION);
    191 
    192   if (direction == SHOWING_CONTROLS && client_->ControlsTopOffset() == 0)
    193     return;
    194 
    195   if (direction == HIDING_CONTROLS &&
    196       client_->ControlsTopOffset() == -top_controls_height_) {
    197     return;
    198   }
    199 
    200   if (top_controls_animation_ && animation_direction_ == direction)
    201     return;
    202 
    203   top_controls_animation_ = KeyframedFloatAnimationCurve::Create();
    204   double start_time =
    205       (gfx::FrameTime::Now() - base::TimeTicks()).InMillisecondsF();
    206   top_controls_animation_->AddKeyframe(
    207       FloatKeyframe::Create(start_time, client_->ControlsTopOffset(),
    208                             scoped_ptr<TimingFunction>()));
    209   float max_ending_offset =
    210       (direction == SHOWING_CONTROLS ? 1 : -1) * top_controls_height_;
    211   top_controls_animation_->AddKeyframe(
    212       FloatKeyframe::Create(start_time + kShowHideMaxDurationMs,
    213                             client_->ControlsTopOffset() + max_ending_offset,
    214                             EaseTimingFunction::Create()));
    215   animation_direction_ = direction;
    216   client_->DidChangeTopControlsPosition();
    217 }
    218 
    219 void TopControlsManager::StartAnimationIfNecessary() {
    220   if (client_->ControlsTopOffset() != 0
    221       && client_->ControlsTopOffset() != -top_controls_height_) {
    222     AnimationDirection show_controls = NO_ANIMATION;
    223 
    224     if (client_->ControlsTopOffset() >= -top_controls_show_height_) {
    225       // If we're showing so much that the hide threshold won't trigger, show.
    226       show_controls = SHOWING_CONTROLS;
    227     } else if (client_->ControlsTopOffset() <= -top_controls_hide_height_) {
    228       // If we're showing so little that the show threshold won't trigger, hide.
    229       show_controls = HIDING_CONTROLS;
    230     } else {
    231       // If we could be either showing or hiding, we determine which one to
    232       // do based on whether or not the total scroll delta was moving up or
    233       // down.
    234       show_controls = current_scroll_delta_ <= 0.f ?
    235           SHOWING_CONTROLS : HIDING_CONTROLS;
    236     }
    237 
    238     if (show_controls != NO_ANIMATION)
    239       SetupAnimation(show_controls);
    240   }
    241 }
    242 
    243 bool TopControlsManager::IsAnimationCompleteAtTime(base::TimeTicks time) {
    244   if (!top_controls_animation_)
    245     return true;
    246 
    247   double time_ms = (time - base::TimeTicks()).InMillisecondsF();
    248   float new_offset = top_controls_animation_->GetValue(time_ms);
    249 
    250   if ((animation_direction_ == SHOWING_CONTROLS && new_offset >= 0) ||
    251       (animation_direction_ == HIDING_CONTROLS
    252           && new_offset <= -top_controls_height_)) {
    253     return true;
    254   }
    255   return false;
    256 }
    257 
    258 }  // namespace cc
    259