Dali 3D User Interface Engine
utc-Dali-TapGestureDetector.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 
18 #include <iostream>
19 
20 #include <stdlib.h>
25 #include <dali-test-suite-utils.h>
26 #include <test-touch-utils.h>
27 
28 using namespace Dali;
29 
31 {
33 }
34 
36 {
38 }
39 
41 namespace
42 {
43 
44 // Stores data that is populated in the callback and will be read by the TET cases
45 struct SignalData
46 {
48  : functorCalled(false),
49  voidFunctorCalled(false)
50  {}
51 
52  void Reset()
53  {
54  functorCalled = false;
55  voidFunctorCalled = false;
56 
57  receivedGesture.numberOfTaps = 0u;
58  receivedGesture.numberOfTouches = 0u;
59  receivedGesture.screenPoint = Vector2(0.0f, 0.0f);
60  receivedGesture.localPoint = Vector2(0.0f, 0.0f);
61 
62  tappedActor.Reset();
63  }
64 
69 };
70 
71 // Functor that sets the data when called
73 {
74  GestureReceivedFunctor(SignalData& data) : signalData(data) { }
75 
76  void operator()(Actor actor, const TapGesture& tap)
77  {
78  signalData.functorCalled = true;
79  signalData.receivedGesture = tap;
80  signalData.tappedActor = actor;
81  }
82 
83  void operator()()
84  {
85  signalData.voidFunctorCalled = true;
86  }
87 
89 };
90 
91 // Functor that removes the gestured actor from stage
93 {
95 
96  void operator()(Actor actor, const TapGesture& tap)
97  {
98  GestureReceivedFunctor::operator()( actor, tap );
99  Stage::GetCurrent().Remove( actor );
100  }
101 };
102 
103 // Functor for receiving a touch event
105 {
106  bool operator()(Actor actor, const TouchEvent& touch)
107  {
108  //For line coverage
109  unsigned int points = touch.GetPointCount();
110  if( points > 0)
111  {
112  const TouchPoint& touchPoint = touch.GetPoint(0);
113  tet_printf("Touch Point state = %d\n", touchPoint.state);
114  }
115  return false;
116  }
117 };
118 
119 // Generate a TapGestureEvent to send to Core
120 Integration::TapGestureEvent GenerateTap(
121  Gesture::State state,
122  unsigned int numberOfTaps,
123  unsigned int numberOfTouches,
124  Vector2 point)
125 {
126  Integration::TapGestureEvent tap( state );
127 
128  tap.numberOfTaps = numberOfTaps;
129  tap.numberOfTouches = numberOfTouches;
130  tap.point = point;
131 
132  return tap;
133 }
134 
135 } // anon namespace
136 
138 
139 
140 // Positive test case for a method
142 {
143  TestApplication application;
144 
145  TapGestureDetector detector;
146  DALI_TEST_CHECK(!detector);
147  END_TEST;
148 }
149 
151 {
152  TestApplication application;
153 
155 
156  TapGestureDetector copy( detector );
157  DALI_TEST_CHECK( detector );
158  END_TEST;
159 }
160 
162 {
163  TestApplication application;
164 
166 
167  TapGestureDetector assign;
168  assign = detector;
169  DALI_TEST_CHECK( detector );
170 
171  DALI_TEST_CHECK( detector == assign );
172  END_TEST;
173 }
174 
176 {
177  TestApplication application;
178 
180  DALI_TEST_CHECK(detector);
183 
185  DALI_TEST_CHECK(detector2);
186  DALI_TEST_EQUALS(5u, detector2.GetMinimumTapsRequired(), TEST_LOCATION);
187  DALI_TEST_EQUALS(5u, detector2.GetMaximumTapsRequired(), TEST_LOCATION);
188 
189  //Scoped test to test destructor
190  {
192  DALI_TEST_CHECK(detector3);
193  }
194 
195  // Attach an actor and emit a touch event on the actor to ensure complete line coverage
196  Actor actor = Actor::New();
197  actor.SetSize(100.0f, 100.0f);
199  Stage::GetCurrent().Add(actor);
200 
201  // Render and notify
202  application.SendNotification();
203  application.Render();
204 
205  detector.Attach(actor);
206 
207  TouchEventFunctor touchFunctor;
208  actor.TouchedSignal().Connect( &application, touchFunctor );
209 
210  Integration::TouchEvent touchEvent(1);
211  TouchPoint point(1, TouchPoint::Down, 20.0f, 20.0f);
212  touchEvent.AddPoint(point);
213  application.ProcessEvent(touchEvent);
214 
215  // Render and notify
216  application.SendNotification();
217  application.Render();
218 
219  // For line coverage, Initialise default constructor
220  TouchEvent touchEvent2;
221  END_TEST;
222 }
223 
225 {
226  TestApplication application;
227  tet_infoline("Testing Dali::TapGestureDetector::DownCast()");
228 
230 
231  BaseHandle object(detector);
232 
234  DALI_TEST_CHECK(detector2);
235 
236  TapGestureDetector detector3 = DownCast< TapGestureDetector >(object);
237  DALI_TEST_CHECK(detector3);
238 
239  BaseHandle unInitializedObject;
240  TapGestureDetector detector4 = TapGestureDetector::DownCast(unInitializedObject);
241  DALI_TEST_CHECK(!detector4);
242 
243  TapGestureDetector detector5 = DownCast< TapGestureDetector >(unInitializedObject);
244  DALI_TEST_CHECK(!detector5);
245 
247  TapGestureDetector detector7 = TapGestureDetector::DownCast(detector6);
248  DALI_TEST_CHECK(detector7);
249  END_TEST;
250 }
251 
253 {
254  TestApplication application;
255 
257 
258  const unsigned int minTaps = 3;
259  const unsigned int maxTaps = 7;
260 
261  DALI_TEST_CHECK( minTaps != detector.GetMinimumTapsRequired() );
262  DALI_TEST_CHECK( maxTaps != detector.GetMaximumTapsRequired() );
263 
264  detector.SetMinimumTapsRequired( minTaps );
265  detector.SetMaximumTapsRequired( maxTaps );
266 
267  DALI_TEST_EQUALS( minTaps, detector.GetMinimumTapsRequired(), TEST_LOCATION );
268  DALI_TEST_EQUALS( maxTaps, detector.GetMaximumTapsRequired(), TEST_LOCATION );
269 
270  // Attach an actor and change the required touches
271 
272  Actor actor = Actor::New();
273  actor.SetSize(100.0f, 100.0f);
274  actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
275  Stage::GetCurrent().Add(actor);
276 
277  // Render and notify
278  application.SendNotification();
279  application.Render();
280 
281  SignalData data;
282  GestureReceivedFunctor functor(data);
283 
284  detector.Attach(actor);
285  detector.DetectedSignal().Connect( &application, functor );
286 
287  // Ensure signal is emitted if minimum taps received
288  application.ProcessEvent(GenerateTap(Gesture::Possible, minTaps, 1u, Vector2(50.0f, 50.0f)));
289  application.ProcessEvent(GenerateTap(Gesture::Started, minTaps, 1u, Vector2(50.0f, 50.0f)));
290  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
291  DALI_TEST_EQUALS( minTaps, data.receivedGesture.numberOfTaps, TEST_LOCATION );
292  data.Reset();
293 
294  // Ensure signal is emitted if maximum taps received
295  application.ProcessEvent(GenerateTap(Gesture::Possible, maxTaps, 1u, Vector2(50.0f, 50.0f)));
296  application.ProcessEvent(GenerateTap(Gesture::Started, maxTaps, 1u, Vector2(50.0f, 50.0f)));
297  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
298  DALI_TEST_EQUALS( maxTaps, data.receivedGesture.numberOfTaps, TEST_LOCATION );
299  data.Reset();
300 
301  // Ensure signal is NOT emitted if outside the range
302  application.ProcessEvent(GenerateTap(Gesture::Possible, minTaps - 1, 1u, Vector2(50.0f, 50.0f)));
303  application.ProcessEvent(GenerateTap(Gesture::Started, minTaps - 1, 1u, Vector2(50.0f, 50.0f)));
304  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
305  data.Reset();
306  application.ProcessEvent(GenerateTap(Gesture::Possible, maxTaps + 1, 1u, Vector2(50.0f, 50.0f)));
307  application.ProcessEvent(GenerateTap(Gesture::Started, maxTaps + 1, 1u, Vector2(50.0f, 50.0f)));
308  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
309  data.Reset();
310 
311  TestGestureManager& gestureManager = application.GetGestureManager();
312  gestureManager.Initialize();
313 
314  detector.SetMinimumTapsRequired(4);
315 
316  // Gesture detection should have been updated only
320 
321  // Reset values
322  gestureManager.Initialize();
323 
324  detector.SetMaximumTapsRequired(maxTaps);
325 
326  // Gesture detection should NOT have been updated
330 
331  // Reset values
332  gestureManager.Initialize();
333 
334  // Create a second gesture detector that requires even less maximum touches
335  TapGestureDetector secondDetector = TapGestureDetector::New();
336  secondDetector.Attach(actor);
337 
338  // Gesture detection should have been updated
342 
343  // Reset values
344  gestureManager.Initialize();
345 
346  // Delete the second detector so that our detection is updated again
347  secondDetector.Reset();
351 
352  // Set the minimum to be greater than the maximum, should Assert
353  try
354  {
355  detector.SetMinimumTapsRequired( maxTaps );
356  detector.SetMaximumTapsRequired( minTaps );
357  DALI_TEST_CHECK( false ); // Should not get here
358  }
359  catch ( DaliException& e )
360  {
361  DALI_TEST_CHECK( true );
362  }
363 
364  END_TEST;
365 }
366 
368 {
369  TestApplication application;
370 
371  // Attach an actor and change the required touches
372 
373  Actor actor = Actor::New();
374  actor.SetSize(100.0f, 100.0f);
376  Stage::GetCurrent().Add(actor);
377 
378  // Render and notify
379  application.SendNotification();
380  application.Render();
381 
382  // Set the minimum to be greater than the maximum, should Assert
383 
384  try
385  {
387  detector.SetMinimumTapsRequired( 7u );
388  detector.SetMaximumTapsRequired( 3u );
389  detector.Attach(actor);
390  DALI_TEST_CHECK( false ); // Should not get here
391  }
392  catch ( DaliException& e )
393  {
394  DALI_TEST_CHECK( true );
395  }
396 
397  END_TEST;
398 }
399 
401 {
402  TestApplication application;
403 
407  END_TEST;
408 }
409 
411 {
412  TestApplication application;
413 
414  Actor actor = Actor::New();
415  actor.SetSize(100.0f, 100.0f);
417  Stage::GetCurrent().Add(actor);
418 
419  // Render and notify
420  application.SendNotification();
421  application.Render();
422 
423  SignalData data;
424  GestureReceivedFunctor functor(data);
425 
427  detector.Attach(actor);
428  detector.DetectedSignal().Connect( &application, functor );
429 
430  // Do a tap outside actor's area
431  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(112.0f, 112.0f)));
432  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(112.0f, 112.0f)));
433  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
434  END_TEST;
435 }
436 
438 {
439  TestApplication application;
440 
441  Actor actor = Actor::New();
442  actor.SetSize(100.0f, 100.0f);
444  Stage::GetCurrent().Add(actor);
445 
446  // Render and notify
447  application.SendNotification();
448  application.Render();
449 
450  SignalData data;
451  GestureReceivedFunctor functor(data);
452 
454  detector.Attach(actor);
455  detector.DetectedSignal().Connect( &application, functor );
456 
457  // Do a tap inside actor's area
458  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 50.0f)));
459  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 50.0f)));
460  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
461  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTaps, TEST_LOCATION);
462  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTouches, TEST_LOCATION);
463  DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.localPoint, 0.1, TEST_LOCATION);
464  END_TEST;
465 }
466 
468 {
469  TestApplication application;
470 
471  Actor actor = Actor::New();
472  actor.SetSize(100.0f, 100.0f);
474  Stage::GetCurrent().Add(actor);
475 
476  // Render and notify
477  application.SendNotification();
478  application.Render();
479 
480  SignalData data;
481  GestureReceivedFunctor functor(data);
482 
484  detector.Attach(actor);
485  detector.DetectedSignal().Connect(&application, functor);
486 
487  // Start tap within the actor's area
488  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 20.0f)));
489  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 20.0f)));
490  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
491  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTaps, TEST_LOCATION);
492  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTouches, TEST_LOCATION);
493  DALI_TEST_EQUALS( Vector2(20.0f, 20.0f), data.receivedGesture.localPoint, 0.1, TEST_LOCATION);
494 
495  // repeat the tap within the actor's area - we should still receive the signal
496  data.Reset();
497  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 50.0f)));
498  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 50.0f)));
499  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
500  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTaps, TEST_LOCATION);
501  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTouches, TEST_LOCATION);
502  DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.localPoint, 0.1, TEST_LOCATION);
503 
504  // Detach actor
505  detector.DetachAll();
506 
507  // Ensure we are no longer signalled
508  data.Reset();
509  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 20.0f)));
510  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 20.0f)));
511  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
512  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 50.0f)));
513  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 50.0f)));
514  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
515  END_TEST;
516 }
517 
519 {
520  TestApplication application;
521 
522  SignalData data;
523  GestureReceivedFunctor functor(data);
524 
526  detector.DetectedSignal().Connect(&application, functor);
527 
528  // Actor lifetime is scoped
529  {
530  Actor actor = Actor::New();
531  actor.SetSize(100.0f, 100.0f);
533  Stage::GetCurrent().Add(actor);
534 
535  // Render and notify
536  application.SendNotification();
537  application.Render();
538 
539  detector.Attach(actor);
540 
541  // Start tap within the actor's area
542  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 20.0f)));
543  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 20.0f)));
544  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
545 
546  // Remove the actor from stage and reset the data
547  Stage::GetCurrent().Remove(actor);
548 
549  // Render and notify
550  application.SendNotification();
551  application.Render();
552  }
553 
554  // Actor should now have been destroyed
555 
556  data.Reset();
557  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 20.0f)));
558  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 20.0f)));
559  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
560  END_TEST;
561 }
562 
564 {
565  TestApplication application;
566 
567  Actor actor = Actor::New();
568  actor.SetSize(100.0f, 100.0f);
570  Stage::GetCurrent().Add(actor);
571 
572  // Render and notify
573  application.SendNotification();
574  application.Render();
575 
576  SignalData data;
577  GestureReceivedFunctor functor(data);
578 
580  detector.Attach(actor);
581  detector.DetectedSignal().Connect(&application, functor);
582 
583  // Do tap, only check finished value
584  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(5.0f, 5.0f)));
585  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(5.0f, 5.0f)));
586  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
587  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTaps, TEST_LOCATION);
588  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTouches, TEST_LOCATION);
589  DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.screenPoint, 0.1, TEST_LOCATION);
590 
591  // Rotate actor again and render
593  application.SendNotification();
594  application.Render();
595 
596  // Do tap, should still receive event
597  data.Reset();
598  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(5.0f, 5.0f)));
599  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(5.0f, 5.0f)));
600  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
601  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTaps, TEST_LOCATION);
602  DALI_TEST_EQUALS(1u, data.receivedGesture.numberOfTouches, TEST_LOCATION);
603  DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.screenPoint, 0.1, TEST_LOCATION);
604 
605  // Rotate actor again and render
607  application.SendNotification();
608  application.Render();
609 
610  // Do tap, inside the actor's area (area if it is not rotated), Should not receive the event
611  data.Reset();
612  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(70.0f, 70.0f)));
613  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(70.0f, 70.0f)));
614  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
615  END_TEST;
616 }
617 
619 {
620  TestApplication application;
621 
622  Actor parent = Actor::New();
623  parent.SetSize(100.0f, 100.0f);
625  Stage::GetCurrent().Add(parent);
626 
627  // Set child to completely cover parent.
628  // Change rotation of child to be different from parent so that we can check if our local coordinate
629  // conversion of the parent actor is correct.
630  Actor child = Actor::New();
631  child.SetSize(100.0f, 100.0f);
635  parent.Add(child);
636 
637  TouchEventFunctor touchFunctor;
638  child.TouchedSignal().Connect(&application, touchFunctor);
639 
640  // Render and notify
641  application.SendNotification();
642  application.Render();
643 
644  SignalData data;
645  GestureReceivedFunctor functor(data);
646 
648  detector.Attach(parent);
649  detector.DetectedSignal().Connect(&application, functor);
650 
651  // Do tap - hits child area but parent should still receive it
652  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 50.0f)));
653  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 50.0f)));
654  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
655  DALI_TEST_EQUALS(true, parent == data.tappedActor, TEST_LOCATION);
656  DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.screenPoint, 0.01f, TEST_LOCATION);
657 
658  // Attach child and generate same touch points
659  // (Also proves that you can detach and then re-attach another actor)
660  detector.Attach(child);
661  detector.Detach(parent);
662 
663  // Do an entire tap, only check finished value
664  data.Reset();
665  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(51.0f, 51.0f)));
666  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(51.0f, 51.0f)));
667  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
668  DALI_TEST_EQUALS(true, child == data.tappedActor, TEST_LOCATION);
669  DALI_TEST_EQUALS(Vector2(51.0f, 51.0f), data.receivedGesture.screenPoint, 0.01f, TEST_LOCATION);
670  END_TEST;
671 }
672 
674 {
675  TestApplication application;
676 
677  Actor first = Actor::New();
678  first.SetSize(100.0f, 100.0f);
680  Stage::GetCurrent().Add(first);
681 
682  Actor second = Actor::New();
683  second.SetSize(100.0f, 100.0f);
684  second.SetX(100.0f);
686  Stage::GetCurrent().Add(second);
687 
688  // Render and notify
689  application.SendNotification();
690  application.Render();
691 
692  SignalData data;
693  GestureReceivedFunctor functor(data);
694 
696  detector.Attach(first);
697  detector.Attach(second);
698  detector.DetectedSignal().Connect(&application, functor);
699 
700  // Tap within second actor's area
701  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(120.0f, 10.0f)));
702  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(120.0f, 10.0f)));
703  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
704  DALI_TEST_EQUALS(true, second == data.tappedActor, TEST_LOCATION);
705 
706  // Tap within first actor's area
707  data.Reset();
708  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 10.0f)));
709  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 10.0f)));
710  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
711  DALI_TEST_EQUALS(true, first == data.tappedActor, TEST_LOCATION);
712 
713  // Detach the second actor
714  detector.Detach(second);
715 
716  // second actor shouldn't receive event
717  data.Reset();
718  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(120.0f, 10.0f)));
719  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(120.0f, 10.0f)));
720  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
721 
722  // first actor should continue receiving event
723  data.Reset();
724  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(20.0f, 10.0f)));
725  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(20.0f, 10.0f)));
726  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
727  END_TEST;
728 }
729 
731 {
732  TestApplication application;
733 
734  Actor actor = Actor::New();
735  actor.SetSize(100.0f, 100.0f);
737  Stage::GetCurrent().Add(actor);
738 
739  // Render and notify
740  application.SendNotification();
741  application.Render();
742 
743  SignalData data;
744  GestureReceivedFunctor functor(data);
745 
747  detector.Attach(actor);
748  detector.DetectedSignal().Connect(&application, functor);
749 
750  // Tap in actor's area
751  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
752  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
753  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
754 
755  // Actor become invisible - actor should not receive the next pan
756  actor.SetVisible(false);
757 
758  // Render and notify
759  application.SendNotification();
760  application.Render();
761 
762  // Tap in the same area, shouldn't receive event
763  data.Reset();
764  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
765  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
766  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
767  END_TEST;
768 }
769 
771 {
772  TestApplication application;
773  Dali::TestGestureManager& gestureManager = application.GetGestureManager();
774 
775  Actor first = Actor::New();
776  first.SetSize(100.0f, 100.0f);
778  Stage::GetCurrent().Add(first);
779 
780  Actor second = Actor::New();
781  second.SetSize(100.0f, 100.0f);
783  second.SetX(100.0f);
784  first.Add(second);
785 
786  // Render and notify
787  application.SendNotification();
788  application.Render();
789 
790  SignalData data;
791  GestureReceivedFunctor functor(data);
792 
794  firstDetector.Attach(first);
795  firstDetector.DetectedSignal().Connect(&application, functor);
796 
797  // secondDetector is scoped
798  {
799  // Reset gestureManager statistics
800  gestureManager.Initialize();
801 
802  TapGestureDetector secondDetector = TapGestureDetector::New( 2 );
803  secondDetector.Attach(second);
804  secondDetector.DetectedSignal().Connect(&application, functor);
805 
809 
810  // Tap within second actor's area
811  application.ProcessEvent(GenerateTap(Gesture::Possible, 2u, 1u, Vector2(150.0f, 10.0f)));
812  application.ProcessEvent(GenerateTap(Gesture::Started, 2u, 1u, Vector2(150.0f, 10.0f)));
813  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
814  DALI_TEST_EQUALS(true, second == data.tappedActor, TEST_LOCATION);
815 
816  // Tap continues as single touch gesture - we should not receive any gesture
817  data.Reset();
818  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(150.0f, 10.0f)));
819  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(150.0f, 10.0f)));
820  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
821 
822  // Single touch tap starts - first actor should be panned
823  data.Reset();
824  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
825  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
826  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
827  DALI_TEST_EQUALS(true, first == data.tappedActor, TEST_LOCATION);
828 
829  // Pan changes to double-touch - we shouldn't receive event
830  data.Reset();
831  application.ProcessEvent(GenerateTap(Gesture::Possible, 2u, 2u, Vector2(50.0f, 10.0f)));
832  application.ProcessEvent(GenerateTap(Gesture::Started, 2u, 2u, Vector2(50.0f, 10.0f)));
833  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
834 
835  // Reset gesture manager statistics
836  gestureManager.Initialize();
837  }
838 
839  // secondDetector has now been deleted. Gesture detection should have been updated only
843  END_TEST;
844 }
845 
847 {
848  TestApplication application;
849 
850  Actor actor = Actor::New();
851  actor.SetSize(100.0f, 100.0f);
853  Stage::GetCurrent().Add(actor);
854 
855  // Render and notify
856  application.SendNotification();
857  application.Render();
858 
859  // Attach actor to one detector
860  SignalData firstData;
861  GestureReceivedFunctor firstFunctor(firstData);
863  firstDetector.Attach(actor);
864  firstDetector.DetectedSignal().Connect(&application, firstFunctor);
865 
866  // Attach actor to another detector
867  SignalData secondData;
868  GestureReceivedFunctor secondFunctor(secondData);
869  TapGestureDetector secondDetector = TapGestureDetector::New();
870  secondDetector.Attach(actor);
871  secondDetector.DetectedSignal().Connect(&application, secondFunctor);
872 
873  // Tap in actor's area - both detector's functors should be called
874  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
875  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
876  DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
877  DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
878  END_TEST;
879 }
880 
882 {
883  TestApplication application;
884 
885  Actor actor = Actor::New();
886  actor.SetSize(100.0f, 100.0f);
888  Stage::GetCurrent().Add(actor);
889 
890  // Render and notify
891  application.SendNotification();
892  application.Render();
893 
894  // Attach actor to detector
895  SignalData data;
896  GestureReceivedFunctor functor( data );
898  detector.Attach(actor);
899  detector.DetectedSignal().Connect( &application, functor );
900 
901  // Gesture possible in actor's area.
902  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
903  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
904 
905  // Move actor somewhere else
906  actor.SetPosition( 100.0f, 100.0f );
907 
908  // Render and notify
909  application.SendNotification();
910  application.Render();
911 
912  // Emit Started event, we should not receive the tap.
913  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
914  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
915 
916  // Tap possible in empty area.
917  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
918  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
919 
920  // Move actor in to the tap position.
921  actor.SetPosition( 0.0f, 0.0f );
922 
923  // Render and notify
924  application.SendNotification();
925  application.Render();
926 
927  // Emit Started event, we should not receive the tap.
928  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
929  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
930 
931  // Normal tap in actor's area for completeness.
932  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
933  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
934  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
935  END_TEST;
936 }
937 
939 {
940  TestApplication application;
941 
942  Actor actor = Actor::New();
943  actor.SetSize(100.0f, 100.0f);
945  Stage::GetCurrent().Add(actor);
946 
947  // Render and notify
948  application.SendNotification();
949  application.Render();
950 
951  // Attach actor to detector
952  SignalData data;
953  GestureReceivedFunctor functor( data );
955  detector.Attach(actor);
956  detector.DetectedSignal().Connect( &application, functor );
957 
958  // Try a Clear state
959  try
960  {
961  application.ProcessEvent(GenerateTap(Gesture::Clear, 1u, 1u, Vector2(50.0f, 10.0f)));
963  }
964  catch ( Dali::DaliException& e )
965  {
966  DALI_TEST_ASSERT( e, "false", TEST_LOCATION );
967  }
968  END_TEST;
969 }
970 
972 {
973  TestApplication application;
974 
975  Actor actor = Actor::New();
976  actor.SetSize(100.0f, 100.0f);
978  Stage::GetCurrent().Add(actor);
979 
980  // Render and notify
981  application.SendNotification();
982  application.Render();
983 
984  // Attach actor to detector
985  SignalData data;
986  GestureReceivedFunctor functor( data );
988  detector.Attach(actor);
989  detector.DetectedSignal().Connect( &application, functor );
990 
991  // Try a Continuing state
992  try
993  {
994  application.ProcessEvent(GenerateTap(Gesture::Continuing, 1u, 1u, Vector2(50.0f, 10.0f)));
996  }
997  catch ( Dali::DaliException& e )
998  {
999  DALI_TEST_ASSERT( e, "false", TEST_LOCATION );
1000  }
1001  END_TEST;
1002 }
1003 
1005 {
1006  TestApplication application;
1007 
1008  Actor actor = Actor::New();
1009  actor.SetSize(100.0f, 100.0f);
1011  Stage::GetCurrent().Add(actor);
1012 
1013  // Render and notify
1014  application.SendNotification();
1015  application.Render();
1016 
1017  // Attach actor to detector
1018  SignalData data;
1019  GestureReceivedFunctor functor( data );
1021  detector.Attach(actor);
1022  detector.DetectedSignal().Connect( &application, functor );
1023 
1024  // Try a Finished state
1025  try
1026  {
1027  application.ProcessEvent(GenerateTap(Gesture::Finished, 1u, 1u, Vector2(50.0f, 10.0f)));
1029  }
1030  catch ( Dali::DaliException& e )
1031  {
1032  DALI_TEST_ASSERT( e, "false", TEST_LOCATION );
1033  }
1034  END_TEST;
1035 }
1036 
1038 {
1039  TestApplication application;
1040 
1041  Actor actor = Actor::New();
1042  actor.SetSize(100.0f, 100.0f);
1044  Stage::GetCurrent().Add(actor);
1045 
1046  // Render and notify
1047  application.SendNotification();
1048  application.Render();
1049 
1050  // Attach actor to detector
1051  SignalData data;
1052  UnstageActorFunctor functor( data );
1054  detector.Attach(actor);
1055  detector.DetectedSignal().Connect( &application, functor );
1056 
1057  // Tap in Actor's area, actor removed in signal handler, should be handled gracefully.
1058  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1059  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
1060  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1061  tet_result( TET_PASS ); // If we get here, then the actor removal on signal handler was handled gracefully.
1062  END_TEST;
1063 }
1064 
1066 {
1067  TestApplication application;
1068 
1069  Actor actor = Actor::New();
1070  actor.SetSize(100.0f, 100.0f);
1072  Stage::GetCurrent().Add(actor);
1073 
1074  // Render and notify
1075  application.SendNotification();
1076  application.Render();
1077 
1078  // Attach actor to detector
1079  SignalData data;
1080  GestureReceivedFunctor functor( data );
1082  detector.Attach(actor);
1083  detector.DetectedSignal().Connect( &application, functor );
1084 
1085  // Emit two possibles
1086  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1087  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1088  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1089 
1090  // Send a couple of Started states, only first one should be received.
1091  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
1092  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1093  data.Reset();
1094  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
1095  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1096 
1097  // Send a couple of cancelled states, no reception
1098  application.ProcessEvent(GenerateTap(Gesture::Cancelled, 1u, 1u, Vector2(50.0f, 10.0f)));
1099  application.ProcessEvent(GenerateTap(Gesture::Cancelled, 1u, 1u, Vector2(50.0f, 10.0f)));
1100  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1101  END_TEST;
1102 }
1103 
1105 {
1106  TestApplication application;
1107 
1108  Actor actor = Actor::New();
1109  actor.SetSize(100.0f, 100.0f);
1111  Stage::GetCurrent().Add(actor);
1112 
1113  // Render and notify
1114  application.SendNotification();
1115  application.Render();
1116 
1117  // Attach actor to detector
1118  SignalData data;
1119  GestureReceivedFunctor functor( data );
1121  detector.Attach(actor);
1122  detector.DetectedSignal().Connect( &application, functor );
1123 
1124  // Emit a possible and then a cancelled, no reception
1125  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1126  application.ProcessEvent(GenerateTap(Gesture::Cancelled, 1u, 1u, Vector2(50.0f, 10.0f)));
1127  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1128  END_TEST;
1129 }
1130 
1132 {
1133  TestApplication application;
1134 
1135  Actor actor = Actor::New();
1136  actor.SetSize(100.0f, 100.0f);
1138  Stage::GetCurrent().Add(actor);
1139 
1140  // Render and notify
1141  application.SendNotification();
1142  application.Render();
1143 
1144  // Attach actor to detector
1145  SignalData data;
1146  GestureReceivedFunctor functor( data );
1148  detector.Attach(actor);
1149  detector.DetectedSignal().Connect( &application, functor );
1150 
1151  // Emit a possible
1152  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1153 
1154  // Detach actor and send a Started state, no signal.
1155  detector.DetachAll();
1156  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
1157  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1158  END_TEST;
1159 }
1160 
1162 {
1163  TestApplication application;
1164 
1165  Actor actor = Actor::New();
1166  actor.SetSize(100.0f, 100.0f);
1168  Stage::GetCurrent().Add(actor);
1169 
1170  // Render and notify
1171  application.SendNotification();
1172  application.Render();
1173 
1174  // Attach actor to detector
1175  SignalData data;
1176  GestureReceivedFunctor functor( data );
1178  detector.Attach(actor);
1179  detector.DetectedSignal().Connect( &application, functor );
1180 
1181  // Emit a possible
1182  application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
1183 
1184  // Remove, render and delete actor
1185  Stage::GetCurrent().Remove(actor);
1186  application.SendNotification();
1187  application.Render();
1188  actor.Reset();
1189 
1190  // Send a Started state, no signal.
1191  application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
1192  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1193  END_TEST;
1194 }
1195 
1197 {
1198  TestApplication application;
1199  Dali::Integration::Core& core = application.GetCore();
1200  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1201  systemOverlay.GetOverlayRenderTasks().CreateTask();
1202 
1203  Actor actor = Actor::New();
1204  actor.SetSize(100.0f, 100.0f);
1206  systemOverlay.Add(actor);
1207 
1208  // Render and notify
1209  application.SendNotification();
1210  application.Render();
1211 
1212  SignalData data;
1213  GestureReceivedFunctor functor(data);
1214 
1216  detector.Attach(actor);
1217  detector.DetectedSignal().Connect(&application, functor);
1218 
1219  Vector2 screenCoords( 50.0f, 50.0f );
1220 
1221  // Do a tap inside actor's area
1222  application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, screenCoords ) );
1223  application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, screenCoords ) );
1224  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1225  END_TEST;
1226 }
1227 
1229 {
1230  TestApplication application;
1231  Dali::Integration::Core& core = application.GetCore();
1232  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1233  systemOverlay.GetOverlayRenderTasks().CreateTask();
1234 
1235  // SystemOverlay actor
1236  Actor systemOverlayActor = Actor::New();
1237  systemOverlayActor.SetSize(100.0f, 100.0f);
1238  systemOverlayActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1239  systemOverlay.Add(systemOverlayActor);
1240 
1241  // Stage actor
1242  Actor stageActor = Actor::New();
1243  stageActor.SetSize(100.0f, 100.0f);
1245  Stage::GetCurrent().Add(stageActor);
1246 
1247  // Render and notify
1248  application.SendNotification();
1249  application.Render();
1250 
1251  // Set system-overlay actor to touchable
1252  TouchEventData touchData;
1253  TouchEventDataFunctor touchFunctor( touchData );
1254  systemOverlayActor.TouchedSignal().Connect(&application, touchFunctor);
1255 
1256  // Set stage actor to receive the gesture
1257  SignalData data;
1258  GestureReceivedFunctor functor(data);
1259 
1261  detector.Attach(stageActor);
1262  detector.DetectedSignal().Connect(&application, functor);
1263 
1264  Vector2 screenCoords( 50.0f, 50.0f );
1265 
1266  // Do a tap inside both actors' area
1267  application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, screenCoords ) );
1268  application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, screenCoords ) );
1269  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1270  DALI_TEST_EQUALS( false, touchData.functorCalled, TEST_LOCATION );
1271 
1272  data.Reset();
1273  touchData.Reset();
1274 
1275  // Do touch in the same area
1276  application.ProcessEvent( touchFunctor.GenerateSingleTouch( TouchPoint::Down, screenCoords ) );
1277  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1278  DALI_TEST_EQUALS( true, touchData.functorCalled, TEST_LOCATION );
1279 
1280  END_TEST;
1281 }
1282 
1284 {
1285  TestApplication application;
1286  Dali::Integration::Core& core = application.GetCore();
1287  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1288  systemOverlay.GetOverlayRenderTasks().CreateTask();
1289 
1290  // SystemOverlay actor
1291  Actor systemOverlayActor = Actor::New();
1292  systemOverlayActor.SetSize(100.0f, 100.0f);
1293  systemOverlayActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1294  systemOverlay.Add(systemOverlayActor);
1295 
1296  // Stage actor
1297  Actor stageActor = Actor::New();
1298  stageActor.SetSize(100.0f, 100.0f);
1300  Stage::GetCurrent().Add(stageActor);
1301 
1302  // Render and notify
1303  application.SendNotification();
1304  application.Render();
1305 
1306  // Set stage actor to touchable
1307  TouchEventData touchData;
1308  TouchEventDataFunctor touchFunctor( touchData );
1309  stageActor.TouchedSignal().Connect(&application, touchFunctor);
1310 
1311  // Set system-overlay actor to have the gesture
1312  SignalData data;
1313  GestureReceivedFunctor functor(data);
1314 
1316  detector.Attach(systemOverlayActor);
1317  detector.DetectedSignal().Connect(&application, functor);
1318 
1319  Vector2 screenCoords( 50.0f, 50.0f );
1320 
1321  // Do a tap inside both actors' area
1322  application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, screenCoords ) );
1323  application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, screenCoords ) );
1324  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1325  DALI_TEST_EQUALS( false, touchData.functorCalled, TEST_LOCATION );
1326 
1327  data.Reset();
1328  touchData.Reset();
1329 
1330  // Do touch in the same area
1331  application.ProcessEvent( touchFunctor.GenerateSingleTouch( TouchPoint::Down, screenCoords ) );
1332  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1333  DALI_TEST_EQUALS( true, touchData.functorCalled, TEST_LOCATION );
1334 
1335  END_TEST;
1336 }
1337 
1339 {
1340  TestApplication application;
1341 
1342  Actor actor = Actor::New();
1343  actor.SetSize(100.0f, 100.0f);
1345  Stage::GetCurrent().Add(actor);
1346 
1347  // Add a detector
1348  SignalData data;
1349  GestureReceivedFunctor functor(data);
1351  detector.Attach(actor);
1352  detector.DetectedSignal().Connect( &application, functor );
1353 
1354  // Add a layer to overlap the actor
1355  Layer layer = Layer::New();
1356  layer.SetSize(100.0f, 100.0f);
1358  Stage::GetCurrent().Add( layer );
1359  layer.RaiseToTop();
1360 
1361  // Render and notify
1362  application.SendNotification();
1363  application.Render();
1364 
1365  Vector2 screenCoords( 50.0f, 50.0f );
1366 
1367  // Emit signals, should receive
1368  application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, screenCoords ) );
1369  application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, screenCoords ) );
1370  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1371  data.Reset();
1372 
1373  // Set layer to consume all touch
1374  layer.SetTouchConsumed( true );
1375 
1376  // Render and notify
1377  application.SendNotification();
1378  application.Render();
1379 
1380  // Emit the same signals again, should not receive
1381  application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, screenCoords ) );
1382  application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, screenCoords ) );
1383  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1384  data.Reset();
1385 
1386  END_TEST;
1387 }
Dali Docs Home
Read more about Dali