5#include "flutter/lib/ui/window/pointer_data_packet_converter.h"
10#include "flutter/fml/logging.h"
19 std::unique_ptr<PointerDataPacket> packet) {
20 std::vector<PointerData> converted_pointers;
23 for (
size_t i = 0; i < packet->GetLength(); i++) {
24 PointerData pointer_data = packet->GetPointerData(i);
25 ConvertPointerData(pointer_data, converted_pointers);
29 auto converted_packet =
30 std::make_unique<flutter::PointerDataPacket>(converted_pointers.size());
32 for (
auto& converted_pointer : converted_pointers) {
33 converted_packet->SetPointerData(
count++, converted_pointer);
36 return converted_packet;
39void PointerDataPacketConverter::ConvertPointerData(
41 std::vector<PointerData>& converted_pointers) {
43 switch (pointer_data.
change) {
49 auto iter = states_.find(pointer_data.
device);
50 if (iter != states_.end()) {
53 UpdatePointerIdentifier(pointer_data,
state,
false);
55 if (LocationNeedsUpdate(pointer_data,
state)) {
61 UpdateDeltaAndState(synthesized_move_event,
state);
62 converted_pointers.push_back(synthesized_move_event);
65 state.is_down =
false;
67 converted_pointers.push_back(pointer_data);
73 EnsurePointerState(pointer_data);
74 converted_pointers.push_back(pointer_data);
79 auto iter = states_.find(pointer_data.
device);
81 PointerState
state = iter->second;
85 PointerData synthesized_cancel_event = pointer_data;
87 synthesized_cancel_event.synthesized = 1;
88 UpdatePointerIdentifier(synthesized_cancel_event,
state,
false);
90 state.is_down =
false;
91 states_[synthesized_cancel_event.device] =
state;
92 converted_pointers.push_back(synthesized_cancel_event);
95 if (LocationNeedsUpdate(pointer_data,
state)) {
97 PointerData synthesized_hover_event = pointer_data;
99 synthesized_hover_event.synthesized = 1;
101 UpdateDeltaAndState(synthesized_hover_event,
state);
102 converted_pointers.push_back(synthesized_hover_event);
105 states_.erase(pointer_data.
device);
106 converted_pointers.push_back(pointer_data);
110 auto iter = states_.find(pointer_data.
device);
112 if (iter == states_.end()) {
114 PointerData synthesized_add_event = pointer_data;
116 synthesized_add_event.synthesized = 1;
117 synthesized_add_event.buttons = 0;
118 state = EnsurePointerState(synthesized_add_event);
119 converted_pointers.push_back(synthesized_add_event);
121 state = iter->second;
126 if (LocationNeedsUpdate(pointer_data,
state)) {
127 UpdateDeltaAndState(pointer_data,
state);
128 converted_pointers.push_back(pointer_data);
133 auto iter = states_.find(pointer_data.
device);
135 if (iter == states_.end()) {
137 PointerData synthesized_add_event = pointer_data;
139 synthesized_add_event.synthesized = 1;
140 synthesized_add_event.buttons = 0;
141 state = EnsurePointerState(synthesized_add_event);
142 converted_pointers.push_back(synthesized_add_event);
144 state = iter->second;
148 if (LocationNeedsUpdate(pointer_data,
state)) {
150 PointerData synthesized_hover_event = pointer_data;
152 synthesized_hover_event.synthesized = 1;
153 synthesized_hover_event.buttons = 0;
155 UpdateDeltaAndState(synthesized_hover_event,
state);
156 converted_pointers.push_back(synthesized_hover_event);
159 UpdatePointerIdentifier(pointer_data,
state,
true);
160 state.is_down =
true;
163 converted_pointers.push_back(pointer_data);
168 auto iter = states_.find(pointer_data.
device);
170 PointerState
state = iter->second;
173 UpdatePointerIdentifier(pointer_data,
state,
false);
174 UpdateDeltaAndState(pointer_data,
state);
176 converted_pointers.push_back(pointer_data);
181 auto iter = states_.find(pointer_data.
device);
183 PointerState
state = iter->second;
186 UpdatePointerIdentifier(pointer_data,
state,
false);
188 if (LocationNeedsUpdate(pointer_data,
state)) {
190 PointerData synthesized_move_event = pointer_data;
192 synthesized_move_event.buttons =
state.buttons;
193 synthesized_move_event.synthesized = 1;
195 UpdateDeltaAndState(synthesized_move_event,
state);
196 converted_pointers.push_back(synthesized_move_event);
199 state.is_down =
false;
202 converted_pointers.push_back(pointer_data);
207 auto iter = states_.find(pointer_data.
device);
209 if (iter == states_.end()) {
211 PointerData synthesized_add_event = pointer_data;
213 synthesized_add_event.synthesized = 1;
214 synthesized_add_event.buttons = 0;
215 state = EnsurePointerState(synthesized_add_event);
216 converted_pointers.push_back(synthesized_add_event);
218 state = iter->second;
222 if (LocationNeedsUpdate(pointer_data,
state)) {
224 PointerData synthesized_hover_event = pointer_data;
226 synthesized_hover_event.synthesized = 1;
227 synthesized_hover_event.buttons = 0;
229 UpdateDeltaAndState(synthesized_hover_event,
state);
230 converted_pointers.push_back(synthesized_hover_event);
233 UpdatePointerIdentifier(pointer_data,
state,
true);
234 state.is_pan_zoom_active =
true;
240 converted_pointers.push_back(pointer_data);
245 auto iter = states_.find(pointer_data.
device);
247 PointerState
state = iter->second;
251 UpdatePointerIdentifier(pointer_data,
state,
false);
252 UpdateDeltaAndState(pointer_data,
state);
254 converted_pointers.push_back(pointer_data);
259 auto iter = states_.find(pointer_data.
device);
261 PointerState
state = iter->second;
264 UpdatePointerIdentifier(pointer_data,
state,
false);
266 if (LocationNeedsUpdate(pointer_data,
state)) {
268 PointerData synthesized_move_event = pointer_data;
270 synthesized_move_event.pan_x =
state.pan_x;
271 synthesized_move_event.pan_y =
state.pan_y;
272 synthesized_move_event.pan_delta_x = 0;
273 synthesized_move_event.pan_delta_y = 0;
274 synthesized_move_event.scale =
state.scale;
275 synthesized_move_event.rotation =
state.rotation;
276 synthesized_move_event.synthesized = 1;
278 UpdateDeltaAndState(synthesized_move_event,
state);
279 converted_pointers.push_back(synthesized_move_event);
282 state.is_pan_zoom_active =
false;
284 converted_pointers.push_back(pointer_data);
288 converted_pointers.push_back(pointer_data);
298 auto iter = states_.find(pointer_data.
device);
301 if (iter == states_.end()) {
303 PointerData synthesized_add_event = pointer_data;
306 synthesized_add_event.synthesized = 1;
307 synthesized_add_event.buttons = 0;
308 state = EnsurePointerState(synthesized_add_event);
309 converted_pointers.push_back(synthesized_add_event);
311 state = iter->second;
314 if (LocationNeedsUpdate(pointer_data,
state)) {
317 PointerData synthesized_move_event = pointer_data;
320 synthesized_move_event.buttons =
state.buttons;
321 synthesized_move_event.synthesized = 1;
323 UpdateDeltaAndState(synthesized_move_event,
state);
324 converted_pointers.push_back(synthesized_move_event);
327 PointerData synthesized_hover_event = pointer_data;
331 synthesized_hover_event.buttons = 0;
332 synthesized_hover_event.synthesized = 1;
334 UpdateDeltaAndState(synthesized_hover_event,
state);
335 converted_pointers.push_back(synthesized_hover_event);
339 converted_pointers.push_back(pointer_data);
350PointerState PointerDataPacketConverter::EnsurePointerState(
351 PointerData pointer_data) {
353 state.pointer_identifier = 0;
354 state.is_down =
false;
355 state.is_pan_zoom_active =
false;
356 state.physical_x = pointer_data.physical_x;
357 state.physical_y = pointer_data.physical_y;
360 states_[pointer_data.device] =
state;
364void PointerDataPacketConverter::UpdateDeltaAndState(PointerData& pointer_data,
365 PointerState&
state) {
366 pointer_data.physical_delta_x = pointer_data.physical_x -
state.physical_x;
367 pointer_data.physical_delta_y = pointer_data.physical_y -
state.physical_y;
368 pointer_data.pan_delta_x = pointer_data.pan_x -
state.pan_x;
369 pointer_data.pan_delta_y = pointer_data.pan_y -
state.pan_y;
370 state.physical_x = pointer_data.physical_x;
371 state.physical_y = pointer_data.physical_y;
372 state.pan_x = pointer_data.pan_x;
373 state.pan_y = pointer_data.pan_y;
374 state.scale = pointer_data.scale;
375 state.rotation = pointer_data.rotation;
376 states_[pointer_data.device] =
state;
379bool PointerDataPacketConverter::LocationNeedsUpdate(
380 const PointerData pointer_data,
381 const PointerState
state) {
382 return state.physical_x != pointer_data.physical_x ||
383 state.physical_y != pointer_data.physical_y;
386void PointerDataPacketConverter::UpdatePointerIdentifier(
387 PointerData& pointer_data,
389 bool start_new_pointer) {
390 if (start_new_pointer) {
391 state.pointer_identifier = ++pointer_;
392 states_[pointer_data.device] =
state;
394 pointer_data.pointer_identifier =
state.pointer_identifier;
~PointerDataPacketConverter()
std::unique_ptr< PointerDataPacket > Convert(std::unique_ptr< PointerDataPacket > packet)
Converts pointer data packet into a form that framework understands. The raw pointer data packet from...
PointerDataPacketConverter()
#define FML_DCHECK(condition)