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@chromium.org for questions about changing these values.
23 const int64 kShowHideMaxDurationMs = 200;
24 }
25
26 // static
Create(TopControlsManagerClient * client,float top_controls_height,float top_controls_show_threshold,float top_controls_hide_threshold)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
TopControlsManager(TopControlsManagerClient * client,float top_controls_height,float top_controls_show_threshold,float top_controls_hide_threshold)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
~TopControlsManager()56 TopControlsManager::~TopControlsManager() {
57 }
58
ControlsTopOffset()59 float TopControlsManager::ControlsTopOffset() {
60 return client_->ControlsTopOffset();
61 }
62
ContentTopOffset()63 float TopControlsManager::ContentTopOffset() {
64 return client_->ControlsTopOffset() + top_controls_height_;
65 }
66
UpdateTopControlsState(TopControlsState constraints,TopControlsState current,bool animate)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
ScrollBegin()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
ScrollBy(const gfx::Vector2dF & pending_delta)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
ScrollEnd()135 void TopControlsManager::ScrollEnd() {
136 DCHECK(!pinch_gesture_active_);
137 StartAnimationIfNecessary();
138 }
139
PinchBegin()140 void TopControlsManager::PinchBegin() {
141 DCHECK(!pinch_gesture_active_);
142 pinch_gesture_active_ = true;
143 StartAnimationIfNecessary();
144 }
145
PinchEnd()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
SetControlsTopOffset(float controls_top_offset)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
Animate(base::TimeTicks monotonic_time)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
ResetAnimations()182 void TopControlsManager::ResetAnimations() {
183 if (top_controls_animation_)
184 top_controls_animation_.reset();
185
186 animation_direction_ = NO_ANIMATION;
187 }
188
SetupAnimation(AnimationDirection direction)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
StartAnimationIfNecessary()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
IsAnimationCompleteAtTime(base::TimeTicks time)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