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