1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
content / browser / renderer_host / direct_manipulation_event_handler_win.cc [blame]
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/browser/renderer_host/direct_manipulation_event_handler_win.h"
#include "base/logging.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "content/browser/renderer_host/direct_manipulation_helper_win.h"
#include "ui/base/ui_base_features.h"
#include "ui/base/win/window_event_target.h"
namespace content {
namespace {
bool FloatEquals(float f1, float f2) {
// The idea behind this is to use this fraction of the larger of the
// two numbers as the limit of the difference. This breaks down near
// zero, so we reuse this as the minimum absolute size we will use
// for the base of the scale too.
static const float epsilon_scale = 0.00001f;
return fabs(f1 - f2) <
epsilon_scale *
std::fmax(std::fmax(std::fabs(f1), std::fabs(f2)), epsilon_scale);
}
} // namespace
DirectManipulationEventHandler::DirectManipulationEventHandler(
ui::WindowEventTarget* event_target)
: event_target_(event_target) {}
bool DirectManipulationEventHandler::SetViewportSizeInPixels(
const gfx::Size& viewport_size_in_pixels) {
if (viewport_size_in_pixels_ == viewport_size_in_pixels)
return false;
viewport_size_in_pixels_ = viewport_size_in_pixels;
return true;
}
void DirectManipulationEventHandler::SetDeviceScaleFactor(
float device_scale_factor) {
device_scale_factor_ = device_scale_factor;
}
void DirectManipulationEventHandler::SetDirectManipulationHelper(
DirectManipulationHelper* helper) {
helper_ = helper;
}
DirectManipulationEventHandler::~DirectManipulationEventHandler() {}
void DirectManipulationEventHandler::TransitionToState(
GestureState new_gesture_state) {
if (gesture_state_ == new_gesture_state)
return;
GestureState previous_gesture_state = gesture_state_;
gesture_state_ = new_gesture_state;
// End the previous sequence.
switch (previous_gesture_state) {
case GestureState::kScroll: {
// kScroll -> kNone, kPinch, ScrollEnd.
// kScroll -> kFling, we don't want to end the current scroll sequence.
if (new_gesture_state != GestureState::kFling)
event_target_->ApplyPanGestureScrollEnd(new_gesture_state ==
GestureState::kPinch);
break;
}
case GestureState::kFling: {
// kFling -> *, FlingEnd.
event_target_->ApplyPanGestureFlingEnd();
break;
}
case GestureState::kPinch: {
DCHECK_EQ(new_gesture_state, GestureState::kNone);
// kPinch -> kNone, PinchEnd. kPinch should only transition to kNone.
event_target_->ApplyPinchZoomEnd();
break;
}
case GestureState::kNone: {
// kNone -> *, no cleanup is needed.
break;
}
default:
NOTREACHED_IN_MIGRATION();
}
// Start the new sequence.
switch (new_gesture_state) {
case GestureState::kScroll: {
// kFling, kNone -> kScroll, ScrollBegin.
// ScrollBegin is different phase event with others. It must send within
// the first scroll event.
should_send_scroll_begin_ = true;
break;
}
case GestureState::kFling: {
// Only kScroll can transition to kFling.
DCHECK_EQ(previous_gesture_state, GestureState::kScroll);
event_target_->ApplyPanGestureFlingBegin();
break;
}
case GestureState::kPinch: {
// * -> kPinch, PinchBegin.
// Pinch gesture may begin with some scroll events.
event_target_->ApplyPinchZoomBegin();
break;
}
case GestureState::kNone: {
// * -> kNone, only cleanup is needed.
break;
}
default:
NOTREACHED_IN_MIGRATION();
}
}
HRESULT DirectManipulationEventHandler::OnViewportStatusChanged(
IDirectManipulationViewport* viewport,
DIRECTMANIPULATION_STATUS current,
DIRECTMANIPULATION_STATUS previous) {
// MSDN never mention |viewport| are nullable and we never saw it is null when
// testing.
DCHECK(viewport);
// The state of our viewport has changed! We'l be in one of three states:
// - ENABLED: initial state
// - READY: the previous gesture has been completed
// - RUNNING: gesture updating
// - INERTIA: finger leave touchpad content still updating by inertia
// Windows should not call this when event_target_ is null since we do not
// pass the DM_POINTERHITTEST to DirectManipulation.
if (!event_target_)
return S_OK;
if (current == previous)
return S_OK;
if (current == DIRECTMANIPULATION_INERTIA) {
// Fling must lead by Scroll. We can actually hit here when user pinch then
// quickly pan gesture and leave touchpad. In this case, we don't want to
// start a new sequence until the gesture end. The rest events in sequence
// will be ignore since sequence still in pinch and only scale factor
// changes will be applied.
if (previous != DIRECTMANIPULATION_RUNNING ||
gesture_state_ != GestureState::kScroll) {
return S_OK;
}
TransitionToState(GestureState::kFling);
}
if (current == DIRECTMANIPULATION_RUNNING) {
// INERTIA -> RUNNING, should start a new sequence.
if (previous == DIRECTMANIPULATION_INERTIA)
TransitionToState(GestureState::kNone);
}
if (current != DIRECTMANIPULATION_READY)
return S_OK;
// Normally gesture sequence will receive 2 READY message, the first one is
// gesture end, the second one is from viewport reset. We don't have content
// transform in the second RUNNING -> READY. We should not reset on an empty
// RUNNING -> READY sequence.
if (last_scale_ != 1.0f || last_x_offset_ != 0 || last_y_offset_ != 0) {
HRESULT hr = viewport->ZoomToRect(
static_cast<float>(0), static_cast<float>(0),
static_cast<float>(viewport_size_in_pixels_.width()),
static_cast<float>(viewport_size_in_pixels_.height()), FALSE);
if (!SUCCEEDED(hr)) {
return hr;
}
}
last_scale_ = 1.0f;
last_x_offset_ = 0.0f;
last_y_offset_ = 0.0f;
TransitionToState(GestureState::kNone);
return S_OK;
}
HRESULT DirectManipulationEventHandler::OnViewportUpdated(
IDirectManipulationViewport* viewport) {
// Nothing to do here.
return S_OK;
}
HRESULT DirectManipulationEventHandler::OnContentUpdated(
IDirectManipulationViewport* viewport,
IDirectManipulationContent* content) {
// MSDN never mention these params are nullable and we never saw they are null
// when testing.
DCHECK(viewport);
DCHECK(content);
// Windows should not call this when event_target_ is null since we do not
// pass the DM_POINTERHITTEST to DirectManipulation.
if (!event_target_)
return S_OK;
float xform[6];
HRESULT hr = content->GetContentTransform(xform, ARRAYSIZE(xform));
if (!SUCCEEDED(hr))
return hr;
float scale = xform[0];
int x_offset = xform[4] / device_scale_factor_;
int y_offset = xform[5] / device_scale_factor_;
// Ignore if Windows pass scale=0 to us.
if (scale == 0.0f) {
LOG(ERROR) << "Windows DirectManipulation API pass scale = 0.";
return hr;
}
// Ignore the scale factor change less than float point rounding error and
// scroll offset change less than 1.
// TODO(crbug.com/41156440) Because we don't fully support fractional scroll,
// pass float scroll offset feels steppy. eg. first x_offset is 0.1 ignored,
// but last_x_offset_ set to 0.1 second x_offset is 1 but x_offset -
// last_x_offset_ is 0.9 ignored.
if (FloatEquals(scale, last_scale_) && x_offset == last_x_offset_ &&
y_offset == last_y_offset_) {
return hr;
}
DCHECK_NE(last_scale_, 0.0f);
// DirectManipulation will send xy transform move to down-right which is noise
// when pinch zoom. We should consider the gesture either Scroll or Pinch at
// one sequence. But Pinch gesture may begin with some scroll transform since
// DirectManipulation recognition maybe wrong at start if the user pinch with
// slow motion. So we allow kScroll -> kPinch.
// Consider this is a Scroll when scale factor equals 1.0.
if (FloatEquals(scale, 1.0f)) {
if (gesture_state_ == GestureState::kNone)
TransitionToState(GestureState::kScroll);
} else {
// Pinch gesture may begin with some scroll events.
TransitionToState(GestureState::kPinch);
}
if (gesture_state_ == GestureState::kScroll) {
if (should_send_scroll_begin_) {
event_target_->ApplyPanGestureScrollBegin(x_offset - last_x_offset_,
y_offset - last_y_offset_);
should_send_scroll_begin_ = false;
} else {
event_target_->ApplyPanGestureScroll(x_offset - last_x_offset_,
y_offset - last_y_offset_);
}
} else if (gesture_state_ == GestureState::kFling) {
event_target_->ApplyPanGestureFling(x_offset - last_x_offset_,
y_offset - last_y_offset_);
} else {
event_target_->ApplyPinchZoomScale(scale / last_scale_);
}
last_scale_ = scale;
last_x_offset_ = x_offset;
last_y_offset_ = y_offset;
return hr;
}
HRESULT DirectManipulationEventHandler::OnInteraction(
IDirectManipulationViewport2* viewport,
DIRECTMANIPULATION_INTERACTION_TYPE interaction) {
if (!helper_)
return S_OK;
if (interaction == DIRECTMANIPULATION_INTERACTION_BEGIN)
helper_->AddAnimationObserver();
else if (interaction == DIRECTMANIPULATION_INTERACTION_END)
helper_->RemoveAnimationObserver();
return S_OK;
}
} // namespace content