Dali 3D User Interface Engine
utc-Dali-PinchGestureDetector.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  receivedGesture(Gesture::Started)
51  {}
52 
53  void Reset()
54  {
55  functorCalled = false;
56  voidFunctorCalled = false;
57 
58  receivedGesture.state = Gesture::Started;
59  receivedGesture.scale = 0.0f;
60  receivedGesture.speed = 0.0f;
61  receivedGesture.screenCenterPoint = Vector2(0.0f, 0.0f);
62  receivedGesture.localCenterPoint = Vector2(0.0f, 0.0f);
63 
64  pinchedActor.Reset();
65  }
66 
71 };
72 
73 // Functor that sets the data when called
75 {
76  GestureReceivedFunctor(SignalData& data) : signalData(data) { }
77 
78  void operator()(Actor actor, const PinchGesture& pinch)
79  {
80  signalData.functorCalled = true;
81  signalData.receivedGesture = pinch;
82  signalData.pinchedActor = actor;
83  }
84 
85  void operator()()
86  {
87  signalData.voidFunctorCalled = true;
88  }
89 
91 };
92 
93 // Functor that removes the gestured actor from stage
95 {
96  UnstageActorFunctor( SignalData& data, Gesture::State& stateToUnstage )
97  : GestureReceivedFunctor( data ),
98  stateToUnstage( stateToUnstage )
99  {
100  }
101 
102  void operator()( Actor actor, const PinchGesture& pinch )
103  {
104  GestureReceivedFunctor::operator()( actor, pinch );
105 
106  if ( pinch.state == stateToUnstage )
107  {
108  Stage::GetCurrent().Remove( actor );
109  }
110  }
111 
113 };
114 
115 // Functor for receiving a touch event
117 {
118  bool operator()(Actor actor, const TouchEvent& touch)
119  {
120  return false;
121  }
122 };
123 
124 // Generate a PinchGestureEvent to send to Core
125 Integration::PinchGestureEvent GeneratePinch(
126  Gesture::State state,
127  float scale,
128  float speed,
129  Vector2 centerpoint)
130 {
131  Integration::PinchGestureEvent pinch(state);
132 
133  pinch.scale = scale;
134  pinch.speed = speed;
135  pinch.centerPoint = centerpoint;
136 
137  return pinch;
138 }
139 
140 } // anon namespace
141 
143 
145 {
146  TestApplication application;
147 
148  PinchGestureDetector detector;
149  DALI_TEST_CHECK(!detector);
150  END_TEST;
151 }
152 
154 {
155  TestApplication application;
156 
158 
159  PinchGestureDetector copy( detector );
160  DALI_TEST_CHECK( detector );
161  END_TEST;
162 }
163 
165 {
166  TestApplication application;
167 
169 
170  PinchGestureDetector assign;
171  assign = detector;
172  DALI_TEST_CHECK( detector );
173 
174  DALI_TEST_CHECK( detector == assign );
175  END_TEST;
176 }
177 
179 {
180  TestApplication application;
181 
183 
184  DALI_TEST_CHECK(detector);
185 
186  // Attach an actor and emit a touch event on the actor to ensure complete line coverage
187  Actor actor = Actor::New();
188  actor.SetSize(100.0f, 100.0f);
190  Stage::GetCurrent().Add(actor);
191 
192  // Render and notify
193  application.SendNotification();
194  application.Render();
195 
196  detector.Attach(actor);
197 
198  Integration::TouchEvent touchEvent(1);
199  TouchPoint point(1, TouchPoint::Down, 20.0f, 20.0f);
200  touchEvent.AddPoint(point);
201  application.ProcessEvent(touchEvent);
202 
203  TouchPoint point2(1, TouchPoint::Down, 20.0f, 20.0f, 20.0f, 20.0f);
204  touchEvent.AddPoint(point2);
205  application.ProcessEvent(touchEvent);
206  END_TEST;
207 }
208 
210 {
211  TestApplication application;
212  tet_infoline("Testing Dali::PinchGestureDetector::DownCast()");
213 
215 
216  BaseHandle object(detector);
217 
219  DALI_TEST_CHECK(detector2);
220 
221  PinchGestureDetector detector3 = DownCast< PinchGestureDetector >(object);
222  DALI_TEST_CHECK(detector3);
223 
224  BaseHandle unInitializedObject;
225  PinchGestureDetector detector4 = PinchGestureDetector::DownCast(unInitializedObject);
226  DALI_TEST_CHECK(!detector4);
227 
228  PinchGestureDetector detector5 = DownCast< PinchGestureDetector >(unInitializedObject);
229  DALI_TEST_CHECK(!detector5);
230 
233  DALI_TEST_CHECK(detector7);
234  END_TEST;
235 }
236 
237 // Negative test case for a method
239 {
240  TestApplication application;
241 
242  Actor actor = Actor::New();
243  actor.SetSize(100.0f, 100.0f);
245  Stage::GetCurrent().Add(actor);
246 
247  // Render and notify
248  application.SendNotification();
249  application.Render();
250 
251  SignalData data;
252  GestureReceivedFunctor functor(data);
253 
255  detector.Attach(actor);
256  detector.DetectedSignal().Connect(&application, functor);
257 
258  // Do a pinch outside actor's area
259  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 45.0f, Vector2(112.0f, 112.0f)));
260  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
261 
262  // Continue pinch into actor's area - we should still not receive the signal
263  data.Reset();
264  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 4.5f, 95.0f, Vector2(20.0f, 20.0f)));
265  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
266 
267  // Stop pinching - we should still not receive the signal
268  data.Reset();
269  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(12.0f, 12.0f)));
270  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
271  END_TEST;
272 }
273 
275 {
276  TestApplication application;
277 
278  Actor actor = Actor::New();
279  actor.SetSize(100.0f, 100.0f);
281  Stage::GetCurrent().Add(actor);
282 
283  // Render and notify
284  application.SendNotification();
285  application.Render();
286 
287  SignalData data;
288  GestureReceivedFunctor functor(data);
289 
291  detector.Attach(actor);
292  detector.DetectedSignal().Connect(&application, functor);
293 
294  // Start pan within the actor's area
295  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 20.0f)));
296  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
297  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
298  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
299  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
300  DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
301 
302  // Continue the pan within the actor's area - we should still receive the signal
303  data.Reset();
304  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 90.0f, Vector2(21.0f, 20.0f)));
305  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
306  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
307  DALI_TEST_EQUALS(5.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
308  DALI_TEST_EQUALS(90.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
309  DALI_TEST_EQUALS(Vector2(21.0f, 20.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
310 
311  // Pan Gesture leaves actor's area - we should still receive the signal
312  data.Reset();
313  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 15.5f, Vector2(320.0f, 10.0f)));
314  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
315  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
316  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
317  DALI_TEST_EQUALS(15.5f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
318  DALI_TEST_EQUALS(Vector2(320.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
319 
320  // Gesture ends - we would receive a finished state
321  data.Reset();
322  application.ProcessEvent(GeneratePinch(Gesture::Finished, 15.2f, 12.1f, Vector2(310.0f, 10.0f)));
323  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
324  DALI_TEST_EQUALS(Gesture::Finished, data.receivedGesture.state, TEST_LOCATION);
325  DALI_TEST_EQUALS(15.2f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
326  DALI_TEST_EQUALS(12.1f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
327  DALI_TEST_EQUALS(Vector2(310.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
328  END_TEST;
329 }
330 
332 {
333  TestApplication application;
334 
335  Actor actor = Actor::New();
336  actor.SetSize(100.0f, 100.0f);
338  Stage::GetCurrent().Add(actor);
339 
340  // Render and notify
341  application.SendNotification();
342  application.Render();
343 
344  SignalData data;
345  GestureReceivedFunctor functor(data);
346 
348  detector.Attach(actor);
349  detector.DetectedSignal().Connect(&application, functor);
350 
351  // Start pinch within the actor's area
352  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 20.0f)));
353  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
354  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
355  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
356  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
357  DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
358 
359  // Continue the pinch within the actor's area - we should still receive the signal
360  data.Reset();
361  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
362  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
363  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
364  DALI_TEST_EQUALS(5.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
365  DALI_TEST_EQUALS(25.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
366  DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
367 
368  // Gesture ends within actor's area - we would receive a finished state
369  data.Reset();
370  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
371  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
372  DALI_TEST_EQUALS(Gesture::Finished, data.receivedGesture.state, TEST_LOCATION);
373  DALI_TEST_EQUALS(5.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
374  DALI_TEST_EQUALS(25.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
375  DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
376  END_TEST;
377 }
378 
380 {
381  TestApplication application;
382 
383  Actor actor = Actor::New();
384  actor.SetSize(100.0f, 100.0f);
386  Stage::GetCurrent().Add(actor);
387 
388  // Render and notify
389  application.SendNotification();
390  application.Render();
391 
392  SignalData data;
393  GestureReceivedFunctor functor(data);
394 
396  detector.Attach(actor);
397  detector.DetectedSignal().Connect(&application, functor);
398 
399  // Start pinch within the actor's area
400  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 20.0f)));
401  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
402  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
403 
404 
405  // Continue the pinch within the actor's area - we should still receive the signal
406  data.Reset();
407  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
408  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
409  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
410 
411  // The gesture is cancelled
412  data.Reset();
413  application.ProcessEvent(GeneratePinch(Gesture::Cancelled, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
414  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
415  DALI_TEST_EQUALS(Gesture::Cancelled, data.receivedGesture.state, TEST_LOCATION);
416  END_TEST;
417 }
418 
420 {
421  TestApplication application;
422 
423  Actor actor = Actor::New();
424  actor.SetSize(100.0f, 100.0f);
426  Stage::GetCurrent().Add(actor);
427 
428  // Render and notify
429  application.SendNotification();
430  application.Render();
431 
432  SignalData data;
433  GestureReceivedFunctor functor(data);
434 
436  detector.Attach(actor);
437  detector.DetectedSignal().Connect(&application, functor);
438 
439  // Start pinch within the actor's area
440  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 20.0f)));
441  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
442  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
443 
444 
445  // Continue the pinch within the actor's area - we should still receive the signal
446  data.Reset();
447  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
448  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
449  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
450 
451  // Gesture ends within actor's area
452  data.Reset();
453  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
454  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
455  DALI_TEST_EQUALS(Gesture::Finished, data.receivedGesture.state, TEST_LOCATION);
456 
457  // Detach actor
458  detector.DetachAll();
459 
460  // Ensure we are no longer signalled
461  data.Reset();
462  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 20.0f)));
463  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
464  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
465  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
466  END_TEST;
467 }
468 
470 {
471  TestApplication application;
472 
473  Actor actor = Actor::New();
474  actor.SetSize(100.0f, 100.0f);
476  Stage::GetCurrent().Add(actor);
477 
478  // Render and notify
479  application.SendNotification();
480  application.Render();
481 
482  SignalData data;
483  GestureReceivedFunctor functor(data);
484 
486  detector.Attach(actor);
487  detector.DetectedSignal().Connect(&application, functor);
488 
489  // Start pinch within the actor's area
490  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
491  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
492  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
493 
494  // Continue the pinch within the actor's area - we should still receive the signal
495  data.Reset();
496  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
497  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
498  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
499 
500  // Detach actor during the pinch, we should not receive the next event
501  detector.DetachAll();
502 
503  // Gesture ends within actor's area
504  data.Reset();
505  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
506  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
507  END_TEST;
508 }
509 
511 {
512  TestApplication application;
513 
514  SignalData data;
515  GestureReceivedFunctor functor(data);
516 
518  detector.DetectedSignal().Connect(&application, functor);
519 
520  // Attach a temporary actor to stop detector being removed from PinchGestureProcessor when main actor
521  // is destroyed.
522  Actor tempActor = Actor::New();
523  tempActor.SetSize(100.0f, 100.0f);
525  Stage::GetCurrent().Add(tempActor);
526  detector.Attach(tempActor);
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 pinch within the actor's area
542  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
543  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
544  DALI_TEST_EQUALS(Gesture::Started, data.receivedGesture.state, TEST_LOCATION);
545 
546  // Continue the pinch within the actor's area - we should still receive the signal
547  data.Reset();
548  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
549  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
550  DALI_TEST_EQUALS(Gesture::Continuing, data.receivedGesture.state, TEST_LOCATION);
551 
552  // Remove the actor from stage and reset the data
553  Stage::GetCurrent().Remove(actor);
554 
555  // Render and notify
556  application.SendNotification();
557  application.Render();
558  }
559 
560  // Actor should now have been destroyed
561 
562  // Gesture ends within the area where the actor used to be
563  data.Reset();
564  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 25.0f, Vector2(20.0f, 20.0f)));
565  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
566  END_TEST;
567 }
568 
570 {
571  TestApplication application;
572 
573  Actor actor = Actor::New();
574  actor.SetSize(100.0f, 100.0f);
576  Stage::GetCurrent().Add(actor);
577 
578  // Render and notify a couple of times
579  application.SendNotification();
580  application.Render();
581 
582  SignalData data;
583  GestureReceivedFunctor functor(data);
584 
586  detector.Attach(actor);
587  detector.DetectedSignal().Connect(&application, functor);
588 
589  // Do an entire pinch, only check finished value
590  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
591  data.Reset();
592  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
593  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
594  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
595  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
596  DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
597 
598  // Rotate actor again and render and notify
600  application.SendNotification();
601  application.Render();
602 
603  // Do an entire pinch, only check finished value
604  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
605  data.Reset();
606  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
607  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
608  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
609  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
610  DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
611 
612  // Rotate actor again and render and notify
614  application.SendNotification();
615  application.Render();
616 
617  // Do an entire pinch, only check finished value
618  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
619  data.Reset();
620  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
621  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
622  DALI_TEST_EQUALS(10.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
623  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
624  DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
625  END_TEST;
626 }
627 
629 {
630  TestApplication application;
631 
632  Actor parent = Actor::New();
633  parent.SetSize(100.0f, 100.0f);
635  Stage::GetCurrent().Add(parent);
636 
637  // Set child to completely cover parent.
638  // Change rotation of child to be different from parent so that we can check if our local coordinate
639  // conversion of the parent actor is correct.
640  Actor child = Actor::New();
641  child.SetSize(100.0f, 100.0f);
645  parent.Add(child);
646 
647  TouchEventFunctor touchFunctor;
648  child.TouchedSignal().Connect(&application, touchFunctor);
649 
650  // Render and notify
651  application.SendNotification();
652  application.Render();
653 
654  SignalData data;
655  GestureReceivedFunctor functor(data);
656 
658  detector.Attach(parent);
659  detector.DetectedSignal().Connect(&application, functor);
660 
661  // Do an entire pan, only check finished value - hits child area but parent should still receive it
662  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
663  data.Reset();
664  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 50.0f, Vector2(10.0f, 10.0f)));
665  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
666  DALI_TEST_EQUALS(true, parent == data.pinchedActor, TEST_LOCATION);
667  DALI_TEST_EQUALS(5.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
668  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
669  DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
670 
671  // Attach child and generate same touch points to yield same results
672  // (Also proves that you can detach and then re-attach another actor)
673  detector.Attach(child);
674  detector.Detach(parent);
675 
676  // Do an entire pan, only check finished value
677  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
678  data.Reset();
679  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 50.0f, Vector2(10.0f, 10.0f)));
680  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
681  DALI_TEST_EQUALS(true, child == data.pinchedActor, TEST_LOCATION);
682  DALI_TEST_EQUALS(5.0f, data.receivedGesture.scale, 0.01f, TEST_LOCATION);
683  DALI_TEST_EQUALS(50.0f, data.receivedGesture.speed, 0.01f, TEST_LOCATION);
684  DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.receivedGesture.screenCenterPoint, 0.01f, TEST_LOCATION);
685  END_TEST;
686 }
687 
689 {
690  TestApplication application;
691 
692  Actor first = Actor::New();
693  first.SetSize(100.0f, 100.0f);
695  Stage::GetCurrent().Add(first);
696 
697  Actor second = Actor::New();
698  second.SetSize(100.0f, 100.0f);
699  second.SetX(100.0f);
701  Stage::GetCurrent().Add(second);
702 
703  // Render and notify
704  application.SendNotification();
705  application.Render();
706 
707  SignalData data;
708  GestureReceivedFunctor functor(data);
709 
711  detector.Attach(first);
712  detector.Attach(second);
713  detector.DetectedSignal().Connect(&application, functor);
714 
715  // Start pinch within second actor's area
716  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(120.0f, 10.0f)));
717  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
718  DALI_TEST_EQUALS(true, second == data.pinchedActor, TEST_LOCATION);
719 
720  // Pinch moves into first actor's area - second actor should receive the pinch
721  data.Reset();
722  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(10.0f, 10.0f)));
723  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
724  DALI_TEST_EQUALS(true, second == data.pinchedActor, TEST_LOCATION);
725 
726  // Detach the second actor during the pinch, we should not receive the next event
727  detector.Detach(second);
728 
729  // Gesture ends within actor's area
730  data.Reset();
731  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(120.0f, 10.0f)));
732  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
733  END_TEST;
734 }
735 
737 {
738  TestApplication application;
739 
740  Actor actor = Actor::New();
741  actor.SetSize(100.0f, 100.0f);
743  Stage::GetCurrent().Add(actor);
744 
745  // Render and notify
746  application.SendNotification();
747  application.Render();
748 
749  SignalData data;
750  GestureReceivedFunctor functor(data);
751 
753  detector.Attach(actor);
754  detector.DetectedSignal().Connect(&application, functor);
755 
756  // Start pinch in actor's area
757  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
758  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
759 
760  // Pan continues within actor's area
761  data.Reset();
762  application.ProcessEvent(GeneratePinch(Gesture::Started, 5.0f, 50.0f, Vector2(10.0f, 10.0f)));
763  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
764 
765  // Actor become invisible - actor should not receive the next pinch
766  actor.SetVisible(false);
767 
768  // Render and notify
769  application.SendNotification();
770  application.Render();
771 
772  // Gesture ends within actor's area
773  data.Reset();
774  application.ProcessEvent(GeneratePinch(Gesture::Finished, 5.0f, 50.0f, Vector2(10.0f, 10.0f)));
775  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
776  END_TEST;
777 }
778 
780 {
781  TestApplication application;
782 
783  Actor actor = Actor::New();
784  actor.SetSize(100.0f, 100.0f);
786  Stage::GetCurrent().Add(actor);
787 
788  Actor actor2 = Actor::New();
789  actor2.SetSize(100.0f, 100.0f);
791  Stage::GetCurrent().Add(actor2);
792 
793  // Render and notify
794  application.SendNotification();
795  application.Render();
796 
797  // Attach actor to one detector
798  SignalData firstData;
799  GestureReceivedFunctor firstFunctor(firstData);
801  firstDetector.Attach(actor);
802  firstDetector.DetectedSignal().Connect(&application, firstFunctor);
803 
804  // Attach actor to another detector
805  SignalData secondData;
806  GestureReceivedFunctor secondFunctor(secondData);
808  secondDetector.Attach(actor);
809  secondDetector.DetectedSignal().Connect(&application, secondFunctor);
810 
811  // Add second actor to second detector, when we remove the actor, this will make sure that this
812  // gesture detector is not removed from the GestureDetectorProcessor. In this scenario, the
813  // functor should still not be called (which is what we're also testing).
814  secondDetector.Attach(actor2);
815 
816  // Pinch in actor's area - both detector's functors should be called
817  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
818  DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
819  DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
820 
821  // Pinch continues in actor's area - both detector's functors should be called
822  firstData.Reset();
823  secondData.Reset();
824  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
825  DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
826  DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
827 
828  // Detach actor from firstDetector and emit pinch on actor, only secondDetector's functor should be called.
829  firstDetector.Detach(actor);
830  firstData.Reset();
831  secondData.Reset();
832  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
833  DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
834  DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
835 
836  // New pinch on actor, only secondDetector has actor attached
837  firstData.Reset();
838  secondData.Reset();
839  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
840  DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
841  DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
842 
843  // Detach actor from secondDetector
844  secondDetector.Detach(actor);
845  firstData.Reset();
846  secondData.Reset();
847  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
848  DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
849  DALI_TEST_EQUALS(false, secondData.functorCalled, TEST_LOCATION);
850  END_TEST;
851 }
852 
854 {
855  // Should handle two started events gracefully.
856 
857  TestApplication application;
858 
859  Actor actor = Actor::New();
860  actor.SetSize(100.0f, 100.0f);
862  Stage::GetCurrent().Add(actor);
863 
864  SignalData data;
865  GestureReceivedFunctor functor(data);
866 
868  detector.Attach(actor);
869  detector.DetectedSignal().Connect(&application, functor);
870 
871  // Render and notify
872  application.SendNotification();
873  application.Render();
874 
875  // Start pan in actor's area
876  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
877  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
878 
879  // Send another start in actor's area
880  data.Reset();
881  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
882  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
883 
884  // Add a child actor to overlap actor and send another start in actor's area
885  Actor child = Actor::New();
886  child.SetSize(100.0f, 100.0f);
889  actor.Add(child);
890 
891  TouchEventFunctor touchFunctor;
892  child.TouchedSignal().Connect(&application, touchFunctor);
893 
894  // Render and notify
895  application.SendNotification();
896  application.Render();
897 
898  // Send another start in actor's area
899  data.Reset();
900  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
901  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
902 
903  // Send another start in actor's area
904  data.Reset();
905  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
906  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
907  END_TEST;
908 }
909 
911 {
912  TestApplication application;
913 
914  Actor actor1 = Actor::New();
915  actor1.SetSize(100.0f, 100.0f);
917  Stage::GetCurrent().Add(actor1);
918  SignalData data1;
919  GestureReceivedFunctor functor1(data1);
921  detector1.Attach(actor1);
922  detector1.DetectedSignal().Connect(&application, functor1);
923 
924  Actor actor2 = Actor::New();
925  actor2.SetSize(100.0f, 100.0f);
928  Stage::GetCurrent().Add(actor2);
929  SignalData data2;
930  GestureReceivedFunctor functor2(data2);
932  detector2.Attach(actor2);
933  detector2.DetectedSignal().Connect(&application, functor2);
934 
935  // Render and notify
936  application.SendNotification();
937  application.Render();
938 
939  // Start pan in actor1's area, only data1 should be set
940  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
941  DALI_TEST_EQUALS(true, data1.functorCalled, TEST_LOCATION);
942  DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
943  END_TEST;
944 }
945 
947 {
948  TestApplication application;
949 
950  Actor actor = Actor::New();
951  actor.SetSize(100.0f, 100.0f);
953  Stage::GetCurrent().Add(actor);
954 
955  // Render and notify
956  application.SendNotification();
957  application.Render();
958 
959  // Attach actor to detector
960  SignalData data;
961  GestureReceivedFunctor functor( data );
963  detector.Attach(actor);
964  detector.DetectedSignal().Connect( &application, functor );
965 
966  // Try a Clear state
967  try
968  {
969  application.ProcessEvent(GeneratePinch(Gesture::Clear, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
971  }
972  catch ( Dali::DaliException& e )
973  {
974  DALI_TEST_ASSERT( e, "false", TEST_LOCATION );
975  }
976  END_TEST;
977 }
978 
980 {
981  TestApplication application;
982 
983  Actor actor = Actor::New();
984  actor.SetSize(100.0f, 100.0f);
986  Stage::GetCurrent().Add(actor);
987 
988  // Render and notify
989  application.SendNotification();
990  application.Render();
991 
992  // Attach actor to detector
993  SignalData data;
994  GestureReceivedFunctor functor( data );
996  detector.Attach(actor);
997  detector.DetectedSignal().Connect( &application, functor );
998 
999  // Try a Possible state
1000  try
1001  {
1002  application.ProcessEvent(GeneratePinch(Gesture::Possible, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1004  }
1005  catch ( Dali::DaliException& e )
1006  {
1007  DALI_TEST_ASSERT( e, "false", TEST_LOCATION );
1008  }
1009  END_TEST;
1010 }
1011 
1013 {
1014  TestApplication application;
1015 
1016  Actor actor = Actor::New();
1017  actor.SetSize(100.0f, 100.0f);
1019  Stage::GetCurrent().Add(actor);
1020 
1021  // Render and notify
1022  application.SendNotification();
1023  application.Render();
1024 
1025  // State to remove actor in.
1026  Gesture::State stateToUnstage( Gesture::Started );
1027 
1028  // Attach actor to detector
1029  SignalData data;
1030  UnstageActorFunctor functor( data, stateToUnstage );
1032  detector.Attach(actor);
1033  detector.DetectedSignal().Connect( &application, functor );
1034 
1035  // Emit signals
1036  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1037  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1038  data.Reset();
1039  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1040  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1041  data.Reset();
1042 
1043  // Render and notify
1044  application.SendNotification();
1045  application.Render();
1046 
1047  // Re-add actor to stage
1048  Stage::GetCurrent().Add(actor);
1049 
1050  // Render and notify
1051  application.SendNotification();
1052  application.Render();
1053 
1054  // Change state to Gesture::Continuing to remove
1055  stateToUnstage = Gesture::Continuing;
1056 
1057  // Emit signals
1058  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1059  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1060  data.Reset();
1061  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1062  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1063  data.Reset();
1064  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1065  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1066  data.Reset();
1067 
1068  // Render and notify
1069  application.SendNotification();
1070  application.Render();
1071 
1072  // Re-add actor to stage
1073  Stage::GetCurrent().Add(actor);
1074 
1075  // Render and notify
1076  application.SendNotification();
1077  application.Render();
1078 
1079  // Change state to Gesture::Continuing to remove
1080  stateToUnstage = Gesture::Finished;
1081 
1082  // Emit signals
1083  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1084  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1085  data.Reset();
1086  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1087  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1088  data.Reset();
1089  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1090  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1091  tet_result( TET_PASS ); // If we get here then we have handled actor stage removal gracefully.
1092  END_TEST;
1093 }
1094 
1096 {
1097  TestApplication application;
1098 
1099  Actor actor = Actor::New();
1100  actor.SetSize(100.0f, 100.0f);
1102  Stage::GetCurrent().Add(actor);
1103 
1104  // Create and add a second actor so that GestureDetector destruction does not come into play.
1105  Actor dummyActor( Actor::New() );
1106  dummyActor.SetSize( 100.0f, 100.0f );
1107  dummyActor.SetPosition( 100.0f, 100.0f );
1109  Stage::GetCurrent().Add(dummyActor);
1110 
1111  // Render and notify
1112  application.SendNotification();
1113  application.Render();
1114 
1115  // State to remove actor in.
1116  Gesture::State stateToUnstage( Gesture::Started );
1117 
1118  // Attach actor to detector
1119  SignalData data;
1120  UnstageActorFunctor functor( data, stateToUnstage );
1122  detector.Attach(actor);
1123  detector.Attach(dummyActor);
1124  detector.DetectedSignal().Connect( &application, functor );
1125 
1126  // Here we are testing a Started actor which is removed in the Started callback, but then added back
1127  // before we get a continuing state. As we were removed from the stage, even if we're at the same
1128  // position, we should still not be signalled.
1129 
1130  // Emit signals
1131  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1132  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1133  data.Reset();
1134 
1135  // Render and notify
1136  application.SendNotification();
1137  application.Render();
1138 
1139  // Re add to the stage, we should not be signalled
1140  Stage::GetCurrent().Add(actor);
1141 
1142  // Render and notify
1143  application.SendNotification();
1144  application.Render();
1145 
1146  // Continue signal emission
1147  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1148  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1149  data.Reset();
1150  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1151  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1152  data.Reset();
1153 
1154  // Here we delete an actor in started, we should not receive any subsequent signalling.
1155 
1156  // Emit signals
1157  application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1158  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1159  data.Reset();
1160 
1161  // Render and notify
1162  application.SendNotification();
1163  application.Render();
1164 
1165  // Delete actor as well
1166  actor.Reset();
1167 
1168  // Render and notify
1169  application.SendNotification();
1170  application.Render();
1171 
1172  // Continue signal emission
1173  application.ProcessEvent(GeneratePinch(Gesture::Continuing, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1174  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1175  data.Reset();
1176  application.ProcessEvent(GeneratePinch(Gesture::Finished, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
1177  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1178  END_TEST;
1179 }
1180 
1182 {
1183  TestApplication application;
1184  Dali::Integration::Core& core = application.GetCore();
1185  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1186  systemOverlay.GetOverlayRenderTasks().CreateTask();
1187 
1188  Actor actor = Actor::New();
1189  actor.SetSize(100.0f, 100.0f);
1191  systemOverlay.Add(actor);
1192 
1193  // Render and notify
1194  application.SendNotification();
1195  application.Render();
1196 
1197  SignalData data;
1198  GestureReceivedFunctor functor(data);
1199 
1201  detector.Attach(actor);
1202  detector.DetectedSignal().Connect(&application, functor);
1203 
1204  Vector2 screenCoords( 50.0f, 50.0f );
1205  float scale ( 10.0f );
1206  float speed ( 50.0f );
1207 
1208  // Start pan within the actor's area
1209  application.ProcessEvent( GeneratePinch( Gesture::Started, scale, speed, screenCoords ) );
1210  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1211  END_TEST;
1212 }
1213 
1215 {
1216  TestApplication application;
1217  Dali::Integration::Core& core = application.GetCore();
1218  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1219  systemOverlay.GetOverlayRenderTasks().CreateTask();
1220 
1221  // SystemOverlay actor
1222  Actor systemOverlayActor = Actor::New();
1223  systemOverlayActor.SetSize(100.0f, 100.0f);
1224  systemOverlayActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1225  systemOverlay.Add(systemOverlayActor);
1226 
1227  // Stage actor
1228  Actor stageActor = Actor::New();
1229  stageActor.SetSize(100.0f, 100.0f);
1231  Stage::GetCurrent().Add(stageActor);
1232 
1233  // Render and notify
1234  application.SendNotification();
1235  application.Render();
1236 
1237  // Set system-overlay actor to touchable
1238  TouchEventData touchData;
1239  TouchEventDataFunctor touchFunctor( touchData );
1240  systemOverlayActor.TouchedSignal().Connect(&application, touchFunctor);
1241 
1242  // Set stage actor to receive the gesture
1243  SignalData data;
1244  GestureReceivedFunctor functor(data);
1245 
1247  detector.Attach(stageActor);
1248  detector.DetectedSignal().Connect(&application, functor);
1249 
1250  Vector2 screenCoords( 50.0f, 50.0f );
1251  float scale ( 10.0f );
1252  float speed ( 50.0f );
1253 
1254  // Start pinch within the two actors' area
1255  application.ProcessEvent( GeneratePinch( Gesture::Started, scale, speed, screenCoords ) );
1256  application.ProcessEvent( GeneratePinch( Gesture::Finished, scale, speed, screenCoords ) );
1257  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1258  DALI_TEST_EQUALS( false, touchData.functorCalled, TEST_LOCATION );
1259 
1260  data.Reset();
1261  touchData.Reset();
1262 
1263  // Do touch in the same area
1264  application.ProcessEvent( touchFunctor.GenerateSingleTouch( TouchPoint::Down, screenCoords ) );
1265  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1266  DALI_TEST_EQUALS( true, touchData.functorCalled, TEST_LOCATION );
1267 
1268  END_TEST;
1269 }
1270 
1272 {
1273  TestApplication application;
1274  Dali::Integration::Core& core = application.GetCore();
1275  Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1276  systemOverlay.GetOverlayRenderTasks().CreateTask();
1277 
1278  // SystemOverlay actor
1279  Actor systemOverlayActor = Actor::New();
1280  systemOverlayActor.SetSize(100.0f, 100.0f);
1281  systemOverlayActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1282  systemOverlay.Add(systemOverlayActor);
1283 
1284  // Stage actor
1285  Actor stageActor = Actor::New();
1286  stageActor.SetSize(100.0f, 100.0f);
1288  Stage::GetCurrent().Add(stageActor);
1289 
1290  // Render and notify
1291  application.SendNotification();
1292  application.Render();
1293 
1294  // Set stage actor to touchable
1295  TouchEventData touchData;
1296  TouchEventDataFunctor touchFunctor( touchData );
1297  stageActor.TouchedSignal().Connect(&application, touchFunctor);
1298 
1299  // Set system-overlay actor to have the gesture
1300  SignalData data;
1301  GestureReceivedFunctor functor(data);
1302 
1304  detector.Attach(systemOverlayActor);
1305  detector.DetectedSignal().Connect(&application, functor);
1306 
1307  Vector2 screenCoords( 50.0f, 50.0f );
1308  float scale ( 10.0f );
1309  float speed ( 50.0f );
1310 
1311  // Start pinch within the two actors' area
1312  application.ProcessEvent( GeneratePinch( Gesture::Started, scale, speed, screenCoords ) );
1313  application.ProcessEvent( GeneratePinch( Gesture::Finished, scale, speed, screenCoords ) );
1314  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1315  DALI_TEST_EQUALS( false, touchData.functorCalled, TEST_LOCATION );
1316 
1317  data.Reset();
1318  touchData.Reset();
1319 
1320  // Do touch in the same area
1321  application.ProcessEvent( touchFunctor.GenerateSingleTouch( TouchPoint::Down, screenCoords ) );
1322  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1323  DALI_TEST_EQUALS( true, touchData.functorCalled, TEST_LOCATION );
1324 
1325  END_TEST;
1326 }
1327 
1329 {
1330  TestApplication application;
1331 
1332  Actor actor = Actor::New();
1333  actor.SetSize(100.0f, 100.0f);
1335  Stage::GetCurrent().Add(actor);
1336 
1337  // Add a detector
1338  SignalData data;
1339  GestureReceivedFunctor functor(data);
1341  detector.Attach(actor);
1342  detector.DetectedSignal().Connect( &application, functor );
1343 
1344  // Add a layer to overlap the actor
1345  Layer layer = Layer::New();
1346  layer.SetSize(100.0f, 100.0f);
1348  Stage::GetCurrent().Add( layer );
1349  layer.RaiseToTop();
1350 
1351  // Render and notify
1352  application.SendNotification();
1353  application.Render();
1354 
1355  Vector2 screenCoords( 50.0f, 50.0f );
1356  float scale ( 10.0f );
1357  float speed ( 50.0f );
1358 
1359  // Emit signals, should receive
1360  application.ProcessEvent( GeneratePinch( Gesture::Started, scale, speed, screenCoords ) );
1361  application.ProcessEvent( GeneratePinch( Gesture::Finished, scale, speed, screenCoords ) );
1362  DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1363  data.Reset();
1364 
1365  // Set layer to consume all touch
1366  layer.SetTouchConsumed( true );
1367 
1368  // Render and notify
1369  application.SendNotification();
1370  application.Render();
1371 
1372  // Emit the same signals again, should not receive
1373  application.ProcessEvent( GeneratePinch( Gesture::Started, scale, speed, screenCoords ) );
1374  application.ProcessEvent( GeneratePinch( Gesture::Finished, scale, speed, screenCoords ) );
1375  DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1376  data.Reset();
1377 
1378  END_TEST;
1379 }
Dali Docs Home
Read more about Dali