Flutter Linux Embedder
Classes | Functions
fl_pointer_manager_test.cc File Reference
#include "flutter/shell/platform/linux/fl_pointer_manager.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Classes

class  FlPointerManagerTest
 

Functions

 TEST_F (FlPointerManagerTest, EnterLeave)
 
 TEST_F (FlPointerManagerTest, EnterEnter)
 
 TEST_F (FlPointerManagerTest, EnterLeaveLeave)
 
 TEST_F (FlPointerManagerTest, EnterButtonPress)
 
 TEST_F (FlPointerManagerTest, NoEnterButtonPress)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleasePrimary)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseSecondary)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseMiddle)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseBack)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseForward)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseThreeButtons)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusPrimaryButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusContact)
 
 TEST_F (FlPointerManagerTest, ButtonPressInvertedStylusContact)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusSecondaryButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusUnknownButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonPressButtonRelease)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseButtonRelease)
 
 TEST_F (FlPointerManagerTest, NoButtonPressButtonRelease)
 
 TEST_F (FlPointerManagerTest, Motion)
 
 TEST_F (FlPointerManagerTest, Drag)
 
 TEST_F (FlPointerManagerTest, DeviceKind)
 

Function Documentation

◆ TEST_F() [1/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonPressButtonRelease   
)

Definition at line 608 of file fl_pointer_manager_test.cc.

608  {
609  StartEngine();
610 
611  std::vector<FlutterPointerEvent> pointer_events;
612  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
613  SendPointerEvent,
614  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
615  size_t events_count) {
616  for (size_t i = 0; i < events_count; i++) {
617  pointer_events.push_back(events[i]);
618  }
619 
620  return kSuccess;
621  }));
622 
623  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
624  fl_pointer_manager_handle_button_press(manager, 1234,
625  kFlutterPointerDeviceKindMouse, 4.0,
626  8.0, GDK_BUTTON_PRIMARY, 0, 0);
627  // Ignore duplicate press
628  fl_pointer_manager_handle_button_press(manager, 1234,
629  kFlutterPointerDeviceKindMouse, 6.0,
630  10.0, GDK_BUTTON_PRIMARY, 0, 0);
631  fl_pointer_manager_handle_button_release(manager, 1235,
632  kFlutterPointerDeviceKindMouse, 5.0,
633  9.0, GDK_BUTTON_PRIMARY, 0, 0);
634 
635  EXPECT_EQ(pointer_events.size(), 3u);
636 
637  // Ignore first synthetic enter event
638  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
639  EXPECT_EQ(pointer_events[1].x, 4.0);
640  EXPECT_EQ(pointer_events[1].y, 8.0);
641  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
642  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
643  EXPECT_EQ(pointer_events[1].view_id, 42);
644  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
645  EXPECT_EQ(pointer_events[2].x, 5.0);
646  EXPECT_EQ(pointer_events[2].y, 9.0);
647  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
648  EXPECT_EQ(pointer_events[2].buttons, 0);
649  EXPECT_EQ(pointer_events[2].view_id, 42);
650 }
g_autoptr
g_autoptr(FlEngine) engine
x
FlFramebuffer double x
Definition: fl_compositor_opengl.cc:47
y
FlFramebuffer double double y
Definition: fl_compositor_opengl.cc:48
fl_engine_get_embedder_api
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:920
fl_pointer_manager_new
FlPointerManager * fl_pointer_manager_new(FlutterViewId view_id, FlEngine *engine)
Definition: fl_pointer_manager.cc:122
fl_pointer_manager_handle_button_press
gboolean fl_pointer_manager_handle_button_press(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
Definition: fl_pointer_manager.cc:133
fl_pointer_manager_handle_button_release
gboolean fl_pointer_manager_handle_button_release(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
Definition: fl_pointer_manager.cc:173
i
int i
Definition: fl_socket_accessible.cc:18
view_id
G_BEGIN_DECLS FlutterViewId view_id
Definition: fl_view_accessible.h:49

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [2/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseBack   
)

Definition at line 322 of file fl_pointer_manager_test.cc.

322  {
323  StartEngine();
324 
325  std::vector<FlutterPointerEvent> pointer_events;
326  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
327  SendPointerEvent,
328  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
329  size_t events_count) {
330  for (size_t i = 0; i < events_count; i++) {
331  pointer_events.push_back(events[i]);
332  }
333 
334  return kSuccess;
335  }));
336 
337  // Forward button is 8 (no GDK define).
338  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
339  fl_pointer_manager_handle_button_press(
340  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 8, 0, 0);
341  fl_pointer_manager_handle_button_release(
342  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 8, 0, 0);
343 
344  EXPECT_EQ(pointer_events.size(), 3u);
345 
346  // Ignore first synthetic enter event
347  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
348  EXPECT_EQ(pointer_events[1].x, 4.0);
349  EXPECT_EQ(pointer_events[1].y, 8.0);
350  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
351  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseBack);
352  EXPECT_EQ(pointer_events[1].view_id, 42);
353  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
354  EXPECT_EQ(pointer_events[2].x, 5.0);
355  EXPECT_EQ(pointer_events[2].y, 9.0);
356  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
357  EXPECT_EQ(pointer_events[2].buttons, 0);
358  EXPECT_EQ(pointer_events[2].view_id, 42);
359 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [3/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseButtonRelease   
)

Definition at line 652 of file fl_pointer_manager_test.cc.

652  {
653  StartEngine();
654 
655  std::vector<FlutterPointerEvent> pointer_events;
656  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
657  SendPointerEvent,
658  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
659  size_t events_count) {
660  for (size_t i = 0; i < events_count; i++) {
661  pointer_events.push_back(events[i]);
662  }
663 
664  return kSuccess;
665  }));
666 
667  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
668  fl_pointer_manager_handle_button_press(manager, 1234,
669  kFlutterPointerDeviceKindMouse, 4.0,
670  8.0, GDK_BUTTON_PRIMARY, 0, 0);
671  fl_pointer_manager_handle_button_release(manager, 1235,
672  kFlutterPointerDeviceKindMouse, 5.0,
673  9.0, GDK_BUTTON_PRIMARY, 0, 0);
674  // Ignore duplicate release
675  fl_pointer_manager_handle_button_release(manager, 1235,
676  kFlutterPointerDeviceKindMouse, 6.0,
677  10.0, GDK_BUTTON_PRIMARY, 0, 0);
678 
679  EXPECT_EQ(pointer_events.size(), 3u);
680 
681  // Ignore first synthetic enter event
682  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
683  EXPECT_EQ(pointer_events[1].x, 4.0);
684  EXPECT_EQ(pointer_events[1].y, 8.0);
685  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
686  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
687  EXPECT_EQ(pointer_events[1].view_id, 42);
688  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
689  EXPECT_EQ(pointer_events[2].x, 5.0);
690  EXPECT_EQ(pointer_events[2].y, 9.0);
691  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
692  EXPECT_EQ(pointer_events[2].buttons, 0);
693  EXPECT_EQ(pointer_events[2].view_id, 42);
694 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [4/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseForward   
)

Definition at line 361 of file fl_pointer_manager_test.cc.

361  {
362  StartEngine();
363 
364  std::vector<FlutterPointerEvent> pointer_events;
365  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
366  SendPointerEvent,
367  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
368  size_t events_count) {
369  for (size_t i = 0; i < events_count; i++) {
370  pointer_events.push_back(events[i]);
371  }
372 
373  return kSuccess;
374  }));
375 
376  // Forward button is 9 (no GDK define).
377  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
378  fl_pointer_manager_handle_button_press(
379  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 9, 0, 0);
380  fl_pointer_manager_handle_button_release(
381  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 9, 0, 0);
382 
383  EXPECT_EQ(pointer_events.size(), 3u);
384 
385  // Ignore first synthetic enter event
386  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
387  EXPECT_EQ(pointer_events[1].x, 4.0);
388  EXPECT_EQ(pointer_events[1].y, 8.0);
389  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
390  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseForward);
391  EXPECT_EQ(pointer_events[1].view_id, 42);
392  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
393  EXPECT_EQ(pointer_events[2].x, 5.0);
394  EXPECT_EQ(pointer_events[2].y, 9.0);
395  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
396  EXPECT_EQ(pointer_events[2].buttons, 0);
397  EXPECT_EQ(pointer_events[2].view_id, 42);
398 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [5/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseMiddle   
)

Definition at line 282 of file fl_pointer_manager_test.cc.

282  {
283  StartEngine();
284 
285  std::vector<FlutterPointerEvent> pointer_events;
286  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
287  SendPointerEvent,
288  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
289  size_t events_count) {
290  for (size_t i = 0; i < events_count; i++) {
291  pointer_events.push_back(events[i]);
292  }
293 
294  return kSuccess;
295  }));
296 
297  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
298  fl_pointer_manager_handle_button_press(manager, 1234,
299  kFlutterPointerDeviceKindMouse, 4.0,
300  8.0, GDK_BUTTON_MIDDLE, 0, 0);
301  fl_pointer_manager_handle_button_release(manager, 1235,
302  kFlutterPointerDeviceKindMouse, 5.0,
303  9.0, GDK_BUTTON_MIDDLE, 0, 0);
304 
305  EXPECT_EQ(pointer_events.size(), 3u);
306 
307  // Ignore first synthetic enter event
308  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
309  EXPECT_EQ(pointer_events[1].x, 4.0);
310  EXPECT_EQ(pointer_events[1].y, 8.0);
311  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
312  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseMiddle);
313  EXPECT_EQ(pointer_events[1].view_id, 42);
314  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
315  EXPECT_EQ(pointer_events[2].x, 5.0);
316  EXPECT_EQ(pointer_events[2].y, 9.0);
317  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
318  EXPECT_EQ(pointer_events[2].buttons, 0);
319  EXPECT_EQ(pointer_events[2].view_id, 42);
320 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [6/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleasePrimary   
)

Definition at line 202 of file fl_pointer_manager_test.cc.

202  {
203  StartEngine();
204 
205  std::vector<FlutterPointerEvent> pointer_events;
206  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
207  SendPointerEvent,
208  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
209  size_t events_count) {
210  for (size_t i = 0; i < events_count; i++) {
211  pointer_events.push_back(events[i]);
212  }
213 
214  return kSuccess;
215  }));
216 
217  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
218  fl_pointer_manager_handle_button_press(manager, 1234,
219  kFlutterPointerDeviceKindMouse, 4.0,
220  8.0, GDK_BUTTON_PRIMARY, 0, 0);
221  fl_pointer_manager_handle_button_release(manager, 1235,
222  kFlutterPointerDeviceKindMouse, 5.0,
223  9.0, GDK_BUTTON_PRIMARY, 0, 0);
224 
225  EXPECT_EQ(pointer_events.size(), 3u);
226 
227  // Ignore first synthetic enter event
228  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
229  EXPECT_EQ(pointer_events[1].x, 4.0);
230  EXPECT_EQ(pointer_events[1].y, 8.0);
231  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
232  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
233  EXPECT_EQ(pointer_events[1].view_id, 42);
234  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
235  EXPECT_EQ(pointer_events[2].x, 5.0);
236  EXPECT_EQ(pointer_events[2].y, 9.0);
237  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
238  EXPECT_EQ(pointer_events[2].buttons, 0);
239  EXPECT_EQ(pointer_events[2].view_id, 42);
240 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [7/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseSecondary   
)

Definition at line 242 of file fl_pointer_manager_test.cc.

242  {
243  StartEngine();
244 
245  std::vector<FlutterPointerEvent> pointer_events;
246  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
247  SendPointerEvent,
248  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
249  size_t events_count) {
250  for (size_t i = 0; i < events_count; i++) {
251  pointer_events.push_back(events[i]);
252  }
253 
254  return kSuccess;
255  }));
256 
257  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
258  fl_pointer_manager_handle_button_press(manager, 1234,
259  kFlutterPointerDeviceKindMouse, 4.0,
260  8.0, GDK_BUTTON_SECONDARY, 0, 0);
261  fl_pointer_manager_handle_button_release(manager, 1235,
262  kFlutterPointerDeviceKindMouse, 5.0,
263  9.0, GDK_BUTTON_SECONDARY, 0, 0);
264 
265  EXPECT_EQ(pointer_events.size(), 3u);
266 
267  // Ignore first synthetic enter event
268  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
269  EXPECT_EQ(pointer_events[1].x, 4.0);
270  EXPECT_EQ(pointer_events[1].y, 8.0);
271  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
272  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseSecondary);
273  EXPECT_EQ(pointer_events[1].view_id, 42);
274  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
275  EXPECT_EQ(pointer_events[2].x, 5.0);
276  EXPECT_EQ(pointer_events[2].y, 9.0);
277  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
278  EXPECT_EQ(pointer_events[2].buttons, 0);
279  EXPECT_EQ(pointer_events[2].view_id, 42);
280 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [8/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseThreeButtons   
)

Definition at line 400 of file fl_pointer_manager_test.cc.

400  {
401  StartEngine();
402 
403  std::vector<FlutterPointerEvent> pointer_events;
404  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
405  SendPointerEvent,
406  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
407  size_t events_count) {
408  for (size_t i = 0; i < events_count; i++) {
409  pointer_events.push_back(events[i]);
410  }
411 
412  return kSuccess;
413  }));
414 
415  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
416  // Press buttons 1-2-3, release 3-2-1
417  fl_pointer_manager_handle_button_press(manager, 1234,
418  kFlutterPointerDeviceKindMouse, 1.0,
419  2.0, GDK_BUTTON_PRIMARY, 0, 0);
420  fl_pointer_manager_handle_button_press(manager, 1235,
421  kFlutterPointerDeviceKindMouse, 3.0,
422  4.0, GDK_BUTTON_SECONDARY, 0, 0);
423  fl_pointer_manager_handle_button_press(manager, 1236,
424  kFlutterPointerDeviceKindMouse, 5.0,
425  6.0, GDK_BUTTON_MIDDLE, 0, 0);
426  fl_pointer_manager_handle_button_release(manager, 1237,
427  kFlutterPointerDeviceKindMouse, 7.0,
428  8.0, GDK_BUTTON_MIDDLE, 0, 0);
429  fl_pointer_manager_handle_button_release(manager, 1238,
430  kFlutterPointerDeviceKindMouse, 9.0,
431  10.0, GDK_BUTTON_SECONDARY, 0, 0);
432  fl_pointer_manager_handle_button_release(
433  manager, 1239, kFlutterPointerDeviceKindMouse, 11.0, 12.0,
434  kFlutterPointerButtonMousePrimary, 0, 0);
435 
436  EXPECT_EQ(pointer_events.size(), 7u);
437 
438  // Ignore first synthetic enter event
439  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
440  EXPECT_EQ(pointer_events[1].x, 1.0);
441  EXPECT_EQ(pointer_events[1].y, 2.0);
442  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
443  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
444  EXPECT_EQ(pointer_events[2].x, 3.0);
445  EXPECT_EQ(pointer_events[2].y, 4.0);
446  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary |
447  kFlutterPointerButtonMouseSecondary);
448  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
449  EXPECT_EQ(pointer_events[3].x, 5.0);
450  EXPECT_EQ(pointer_events[3].y, 6.0);
451  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary |
452  kFlutterPointerButtonMouseSecondary |
453  kFlutterPointerButtonMouseMiddle);
454  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
455  EXPECT_EQ(pointer_events[4].x, 7.0);
456  EXPECT_EQ(pointer_events[4].y, 8.0);
457  EXPECT_EQ(pointer_events[4].buttons, kFlutterPointerButtonMousePrimary |
458  kFlutterPointerButtonMouseSecondary);
459  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
460  EXPECT_EQ(pointer_events[5].x, 9.0);
461  EXPECT_EQ(pointer_events[5].y, 10.0);
462  EXPECT_EQ(pointer_events[5].buttons, kFlutterPointerButtonMousePrimary);
463  EXPECT_EQ(pointer_events[6].timestamp, 1239000u);
464  EXPECT_EQ(pointer_events[6].x, 11.0);
465  EXPECT_EQ(pointer_events[6].y, 12.0);
466  EXPECT_EQ(pointer_events[6].buttons, 0);
467 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, x, and y.

◆ TEST_F() [9/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressInvertedStylusContact   
)

Definition at line 527 of file fl_pointer_manager_test.cc.

527  {
528  StartEngine();
529 
530  constexpr int64_t kStylusContact = 1 << 0;
531 
532  std::vector<FlutterPointerEvent> pointer_events;
533  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
534  SendPointerEvent,
535  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
536  size_t events_count) {
537  for (size_t i = 0; i < events_count; i++) {
538  pointer_events.push_back(events[i]);
539  }
540 
541  return kSuccess;
542  }));
543 
544  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
545  fl_pointer_manager_handle_button_press(
546  manager, 1234, kFlutterPointerDeviceKindInvertedStylus, 4.0, 8.0,
547  GDK_BUTTON_PRIMARY, 0.0, 0.5);
548 
549  EXPECT_EQ(pointer_events.size(), 2u);
550  EXPECT_EQ(pointer_events[1].device_kind,
551  kFlutterPointerDeviceKindInvertedStylus);
552  EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
553 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [10/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusContact   
)

Definition at line 500 of file fl_pointer_manager_test.cc.

500  {
501  StartEngine();
502 
503  constexpr int64_t kStylusContact = 1 << 0;
504 
505  std::vector<FlutterPointerEvent> pointer_events;
506  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
507  SendPointerEvent,
508  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
509  size_t events_count) {
510  for (size_t i = 0; i < events_count; i++) {
511  pointer_events.push_back(events[i]);
512  }
513 
514  return kSuccess;
515  }));
516 
517  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
518  fl_pointer_manager_handle_button_press(manager, 1234,
519  kFlutterPointerDeviceKindStylus, 4.0,
520  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
521 
522  EXPECT_EQ(pointer_events.size(), 2u);
523  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindStylus);
524  EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
525 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [11/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusPrimaryButton   
)

Definition at line 469 of file fl_pointer_manager_test.cc.

469  {
470  StartEngine();
471 
472  constexpr int64_t kStylusContact = 1 << 0;
473  constexpr int64_t kStylusPrimary = 1 << 1;
474 
475  std::vector<FlutterPointerEvent> pointer_events;
476  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
477  SendPointerEvent,
478  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
479  size_t events_count) {
480  for (size_t i = 0; i < events_count; i++) {
481  pointer_events.push_back(events[i]);
482  }
483 
484  return kSuccess;
485  }));
486 
487  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
488  fl_pointer_manager_handle_button_press(manager, 1234,
489  kFlutterPointerDeviceKindStylus, 4.0,
490  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
491  fl_pointer_manager_handle_button_press(manager, 1235,
492  kFlutterPointerDeviceKindStylus, 4.0,
493  8.0, GDK_BUTTON_SECONDARY, 0.0, 0.5);
494 
495  EXPECT_EQ(pointer_events.size(), 3u);
496  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
497  EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusPrimary);
498 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [12/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusSecondaryButton   
)

Definition at line 555 of file fl_pointer_manager_test.cc.

555  {
556  StartEngine();
557 
558  constexpr int64_t kStylusContact = 1 << 0;
559  constexpr int64_t kStylusSecondary = 1 << 2;
560 
561  std::vector<FlutterPointerEvent> pointer_events;
562  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
563  SendPointerEvent,
564  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
565  size_t events_count) {
566  for (size_t i = 0; i < events_count; i++) {
567  pointer_events.push_back(events[i]);
568  }
569 
570  return kSuccess;
571  }));
572 
573  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
574  fl_pointer_manager_handle_button_press(manager, 1234,
575  kFlutterPointerDeviceKindStylus, 4.0,
576  8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
577  fl_pointer_manager_handle_button_press(manager, 1235,
578  kFlutterPointerDeviceKindStylus, 4.0,
579  8.0, GDK_BUTTON_MIDDLE, 0.0, 0.5);
580 
581  EXPECT_EQ(pointer_events.size(), 3u);
582  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
583  EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusSecondary);
584 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [13/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusUnknownButton   
)

Definition at line 586 of file fl_pointer_manager_test.cc.

586  {
587  StartEngine();
588 
589  std::vector<FlutterPointerEvent> pointer_events;
590  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
591  SendPointerEvent,
592  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
593  size_t events_count) {
594  for (size_t i = 0; i < events_count; i++) {
595  pointer_events.push_back(events[i]);
596  }
597 
598  return kSuccess;
599  }));
600 
601  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
602  fl_pointer_manager_handle_button_press(
603  manager, 1234, kFlutterPointerDeviceKindStylus, 4.0, 8.0, 8, 0, 0);
604 
605  EXPECT_EQ(pointer_events.size(), 0u);
606 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [14/22]

TEST_F ( FlPointerManagerTest  ,
DeviceKind   
)

Definition at line 825 of file fl_pointer_manager_test.cc.

825  {
826  StartEngine();
827 
828  std::vector<FlutterPointerEvent> pointer_events;
829  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
830  SendPointerEvent,
831  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
832  size_t events_count) {
833  for (size_t i = 0; i < events_count; i++) {
834  pointer_events.push_back(events[i]);
835  }
836 
837  return kSuccess;
838  }));
839 
840  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
841  fl_pointer_manager_handle_enter(
842  manager, 1234, kFlutterPointerDeviceKindTrackpad, 1.0, 2.0, 0, 0);
843  fl_pointer_manager_handle_button_press(manager, 1235,
844  kFlutterPointerDeviceKindTrackpad, 1.0,
845  2.0, GDK_BUTTON_PRIMARY, 0, 0);
846  fl_pointer_manager_handle_motion(
847  manager, 1238, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
848  fl_pointer_manager_handle_button_release(manager, 1237,
849  kFlutterPointerDeviceKindTrackpad,
850  3.0, 4.0, GDK_BUTTON_PRIMARY, 0, 0);
851  fl_pointer_manager_handle_leave(
852  manager, 1235, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
853 
854  EXPECT_EQ(pointer_events.size(), 5u);
855 
856  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
857  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindTrackpad);
858  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTrackpad);
859  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTrackpad);
860  EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindTrackpad);
861 }
fl_pointer_manager_handle_enter
gboolean fl_pointer_manager_handle_enter(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition: fl_pointer_manager.cc:235
fl_pointer_manager_handle_motion
gboolean fl_pointer_manager_handle_motion(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition: fl_pointer_manager.cc:211
fl_pointer_manager_handle_leave
gboolean fl_pointer_manager_handle_leave(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition: fl_pointer_manager.cc:254

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [15/22]

TEST_F ( FlPointerManagerTest  ,
Drag   
)

Definition at line 766 of file fl_pointer_manager_test.cc.

766  {
767  StartEngine();
768 
769  std::vector<FlutterPointerEvent> pointer_events;
770  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
771  SendPointerEvent,
772  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
773  size_t events_count) {
774  for (size_t i = 0; i < events_count; i++) {
775  pointer_events.push_back(events[i]);
776  }
777 
778  return kSuccess;
779  }));
780 
781  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
782  fl_pointer_manager_handle_motion(
783  manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
784  fl_pointer_manager_handle_button_press(manager, 1235,
785  kFlutterPointerDeviceKindMouse, 3.0,
786  4.0, GDK_BUTTON_PRIMARY, 0, 0);
787  fl_pointer_manager_handle_motion(
788  manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
789  fl_pointer_manager_handle_button_release(manager, 1237,
790  kFlutterPointerDeviceKindMouse, 7.0,
791  8.0, GDK_BUTTON_PRIMARY, 0, 0);
792  fl_pointer_manager_handle_motion(
793  manager, 1238, kFlutterPointerDeviceKindMouse, 9.0, 10.0, 0, 0);
794 
795  EXPECT_EQ(pointer_events.size(), 6u);
796 
797  // Ignore first synthetic enter event
798  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
799  EXPECT_EQ(pointer_events[1].x, 1.0);
800  EXPECT_EQ(pointer_events[1].y, 2.0);
801  EXPECT_EQ(pointer_events[1].buttons, 0);
802  EXPECT_EQ(pointer_events[1].view_id, 42);
803  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
804  EXPECT_EQ(pointer_events[2].x, 3.0);
805  EXPECT_EQ(pointer_events[2].y, 4.0);
806  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary);
807  EXPECT_EQ(pointer_events[2].view_id, 42);
808  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
809  EXPECT_EQ(pointer_events[3].x, 5.0);
810  EXPECT_EQ(pointer_events[3].y, 6.0);
811  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary);
812  EXPECT_EQ(pointer_events[3].view_id, 42);
813  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
814  EXPECT_EQ(pointer_events[4].x, 7.0);
815  EXPECT_EQ(pointer_events[4].y, 8.0);
816  EXPECT_EQ(pointer_events[4].buttons, 0);
817  EXPECT_EQ(pointer_events[4].view_id, 42);
818  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
819  EXPECT_EQ(pointer_events[5].x, 9.0);
820  EXPECT_EQ(pointer_events[5].y, 10.0);
821  EXPECT_EQ(pointer_events[5].buttons, 0);
822  EXPECT_EQ(pointer_events[5].view_id, 42);
823 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [16/22]

TEST_F ( FlPointerManagerTest  ,
EnterButtonPress   
)

Definition at line 125 of file fl_pointer_manager_test.cc.

125  {
126  StartEngine();
127 
128  std::vector<FlutterPointerEvent> pointer_events;
129  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
130  SendPointerEvent,
131  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
132  size_t events_count) {
133  for (size_t i = 0; i < events_count; i++) {
134  pointer_events.push_back(events[i]);
135  }
136 
137  return kSuccess;
138  }));
139 
140  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
141  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
142  1.0, 2.0, 0, 0);
143  fl_pointer_manager_handle_button_press(manager, 1235,
144  kFlutterPointerDeviceKindMouse, 4.0,
145  8.0, GDK_BUTTON_PRIMARY, 0, 0);
146 
147  EXPECT_EQ(pointer_events.size(), 2u);
148 
149  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
150  EXPECT_EQ(pointer_events[0].x, 1.0);
151  EXPECT_EQ(pointer_events[0].y, 2.0);
152  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
153  EXPECT_EQ(pointer_events[0].buttons, 0);
154  EXPECT_EQ(pointer_events[0].view_id, 42);
155 
156  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
157  EXPECT_EQ(pointer_events[1].x, 4.0);
158  EXPECT_EQ(pointer_events[1].y, 8.0);
159  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
160  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
161  EXPECT_EQ(pointer_events[1].view_id, 42);
162 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [17/22]

TEST_F ( FlPointerManagerTest  ,
EnterEnter   
)

Definition at line 52 of file fl_pointer_manager_test.cc.

52  {
53  StartEngine();
54 
55  std::vector<FlutterPointerEvent> pointer_events;
56  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
57  SendPointerEvent,
58  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
59  size_t events_count) {
60  for (size_t i = 0; i < events_count; i++) {
61  pointer_events.push_back(events[i]);
62  }
63 
64  return kSuccess;
65  }));
66 
67  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
68  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
69  1.0, 2.0, 0, 0);
70  // Duplicate enter is ignored
71  fl_pointer_manager_handle_enter(manager, 1235, kFlutterPointerDeviceKindMouse,
72  3.0, 4.0, 0, 0);
73 
74  EXPECT_EQ(pointer_events.size(), 1u);
75 
76  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
77  EXPECT_EQ(pointer_events[0].x, 1.0);
78  EXPECT_EQ(pointer_events[0].y, 2.0);
79  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
80  EXPECT_EQ(pointer_events[0].buttons, 0);
81  EXPECT_EQ(pointer_events[0].view_id, 42);
82 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [18/22]

TEST_F ( FlPointerManagerTest  ,
EnterLeave   
)

Definition at line 14 of file fl_pointer_manager_test.cc.

14  {
15  StartEngine();
16 
17  std::vector<FlutterPointerEvent> pointer_events;
18  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
19  SendPointerEvent,
20  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
21  size_t events_count) {
22  for (size_t i = 0; i < events_count; i++) {
23  pointer_events.push_back(events[i]);
24  }
25 
26  return kSuccess;
27  }));
28 
29  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
30  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
31  1.0, 2.0, 0, 0);
32  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
33  3.0, 4.0, 0, 0);
34 
35  EXPECT_EQ(pointer_events.size(), 2u);
36 
37  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
38  EXPECT_EQ(pointer_events[0].x, 1.0);
39  EXPECT_EQ(pointer_events[0].y, 2.0);
40  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
41  EXPECT_EQ(pointer_events[0].buttons, 0);
42  EXPECT_EQ(pointer_events[0].view_id, 42);
43 
44  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
45  EXPECT_EQ(pointer_events[1].x, 3.0);
46  EXPECT_EQ(pointer_events[1].y, 4.0);
47  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
48  EXPECT_EQ(pointer_events[1].buttons, 0);
49  EXPECT_EQ(pointer_events[1].view_id, 42);
50 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [19/22]

TEST_F ( FlPointerManagerTest  ,
EnterLeaveLeave   
)

Definition at line 84 of file fl_pointer_manager_test.cc.

84  {
85  StartEngine();
86 
87  std::vector<FlutterPointerEvent> pointer_events;
88  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
89  SendPointerEvent,
90  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
91  size_t events_count) {
92  for (size_t i = 0; i < events_count; i++) {
93  pointer_events.push_back(events[i]);
94  }
95 
96  return kSuccess;
97  }));
98 
99  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
100  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
101  1.0, 2.0, 0, 0);
102  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
103  3.0, 4.0, 0, 0);
104  // Duplicate leave is ignored
105  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
106  5.0, 6.0, 0, 0);
107 
108  EXPECT_EQ(pointer_events.size(), 2u);
109 
110  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
111  EXPECT_EQ(pointer_events[0].x, 1.0);
112  EXPECT_EQ(pointer_events[0].y, 2.0);
113  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
114  EXPECT_EQ(pointer_events[0].buttons, 0);
115  EXPECT_EQ(pointer_events[0].view_id, 42);
116 
117  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
118  EXPECT_EQ(pointer_events[1].x, 3.0);
119  EXPECT_EQ(pointer_events[1].y, 4.0);
120  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
121  EXPECT_EQ(pointer_events[1].buttons, 0);
122  EXPECT_EQ(pointer_events[1].view_id, 42);
123 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [20/22]

TEST_F ( FlPointerManagerTest  ,
Motion   
)

Definition at line 720 of file fl_pointer_manager_test.cc.

720  {
721  StartEngine();
722 
723  std::vector<FlutterPointerEvent> pointer_events;
724  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
725  SendPointerEvent,
726  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
727  size_t events_count) {
728  for (size_t i = 0; i < events_count; i++) {
729  pointer_events.push_back(events[i]);
730  }
731 
732  return kSuccess;
733  }));
734 
735  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
736  fl_pointer_manager_handle_motion(
737  manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
738  fl_pointer_manager_handle_motion(
739  manager, 1235, kFlutterPointerDeviceKindMouse, 3.0, 4.0, 0, 0);
740  fl_pointer_manager_handle_motion(
741  manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
742 
743  EXPECT_EQ(pointer_events.size(), 4u);
744 
745  // Ignore first synthetic enter event
746  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
747  EXPECT_EQ(pointer_events[1].x, 1.0);
748  EXPECT_EQ(pointer_events[1].y, 2.0);
749  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
750  EXPECT_EQ(pointer_events[1].buttons, 0);
751  EXPECT_EQ(pointer_events[1].view_id, 42);
752  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
753  EXPECT_EQ(pointer_events[2].x, 3.0);
754  EXPECT_EQ(pointer_events[2].y, 4.0);
755  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
756  EXPECT_EQ(pointer_events[2].buttons, 0);
757  EXPECT_EQ(pointer_events[2].view_id, 42);
758  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
759  EXPECT_EQ(pointer_events[3].x, 5.0);
760  EXPECT_EQ(pointer_events[3].y, 6.0);
761  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindMouse);
762  EXPECT_EQ(pointer_events[3].buttons, 0);
763  EXPECT_EQ(pointer_events[3].view_id, 42);
764 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.

◆ TEST_F() [21/22]

TEST_F ( FlPointerManagerTest  ,
NoButtonPressButtonRelease   
)

Definition at line 696 of file fl_pointer_manager_test.cc.

696  {
697  StartEngine();
698 
699  std::vector<FlutterPointerEvent> pointer_events;
700  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
701  SendPointerEvent,
702  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
703  size_t events_count) {
704  for (size_t i = 0; i < events_count; i++) {
705  pointer_events.push_back(events[i]);
706  }
707 
708  return kSuccess;
709  }));
710 
711  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
712  // Release without associated press, will be ignored
713  fl_pointer_manager_handle_button_release(manager, 1235,
714  kFlutterPointerDeviceKindMouse, 5.0,
715  9.0, GDK_BUTTON_PRIMARY, 0, 0);
716 
717  EXPECT_EQ(pointer_events.size(), 0u);
718 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), and i.

◆ TEST_F() [22/22]

TEST_F ( FlPointerManagerTest  ,
NoEnterButtonPress   
)

Definition at line 164 of file fl_pointer_manager_test.cc.

164  {
165  StartEngine();
166 
167  std::vector<FlutterPointerEvent> pointer_events;
168  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
169  SendPointerEvent,
170  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
171  size_t events_count) {
172  for (size_t i = 0; i < events_count; i++) {
173  pointer_events.push_back(events[i]);
174  }
175 
176  return kSuccess;
177  }));
178 
179  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
180  fl_pointer_manager_handle_button_press(manager, 1234,
181  kFlutterPointerDeviceKindMouse, 4.0,
182  8.0, GDK_BUTTON_PRIMARY, 0, 0);
183 
184  EXPECT_EQ(pointer_events.size(), 2u);
185 
186  // Synthetic enter events
187  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
188  EXPECT_EQ(pointer_events[0].x, 4.0);
189  EXPECT_EQ(pointer_events[0].y, 8.0);
190  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
191  EXPECT_EQ(pointer_events[0].buttons, 0);
192  EXPECT_EQ(pointer_events[0].view_id, 42);
193 
194  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
195  EXPECT_EQ(pointer_events[1].x, 4.0);
196  EXPECT_EQ(pointer_events[1].y, 8.0);
197  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
198  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
199  EXPECT_EQ(pointer_events[1].view_id, 42);
200 }

References fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, view_id, x, and y.