cc/input/top_controls_manager.cc

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