automated-tests/src/dali/utc-Dali-TouchProcessing.cpp

   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>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali/integration-api/events/touch-event-integ.h>
  23 #include <dali/integration-api/system-overlay.h>
  24 #include <dali-test-suite-utils.h>
  25
  26 using namespace Dali;
  27
  28 void utc_dali_touch_processing_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void utc_dali_touch_processing_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39
  40 namespace
  41 {
  42
  43 // Stores data that is populated in the callback and will be read by the TET cases
  44 struct SignalData
  45 {
  46   SignalData()
  47   : functorCalled( false ),
  48     touchEvent(),
  49     touchedActor()
  50   {
  51   }
  52
  53   void Reset()
  54   {
  55     functorCalled = false;
  56
  57     touchEvent.time = 0u;
  58     touchEvent.points.clear();
  59
  60     touchedActor.Reset();
  61   }
  62
  63   bool functorCalled;
  64   TouchEvent touchEvent;
  65   Actor touchedActor;
  66 };
  67
  68 // Functor that sets the data when called
  69 struct TouchEventFunctor
  70 {
  71   /**
  72    * Constructor.
  73    * @param[in]  data         Reference to the data to store callback information.
  74    * @param[in]  returnValue  What the functor should return.
  75    */
  76   TouchEventFunctor( SignalData& data, bool returnValue = true )
  77   : signalData( data ),
  78     returnValue( returnValue )
  79   {
  80   }
  81
  82   bool operator()( Actor actor, const TouchEvent& touchEvent )
  83   {
  84     signalData.functorCalled = true;
  85     signalData.touchedActor = actor;
  86     signalData.touchEvent = touchEvent;
  87
  88     return returnValue;
  89   }
  90
  91   SignalData& signalData;
  92   bool returnValue;
  93 };
  94
  95 // Functor that removes the actor when called.
  96 struct RemoveActorFunctor : public TouchEventFunctor
  97 {
  98   /**
  99    * Constructor.
 100    * @param[in]  data         Reference to the data to store callback information.
 101    * @param[in]  returnValue  What the functor should return.
 102    */
 103   RemoveActorFunctor( SignalData& data, bool returnValue = true )
 104   : TouchEventFunctor( data, returnValue )
 105   {
 106   }
 107
 108   bool operator()( Actor actor, const TouchEvent& touchEvent )
 109   {
 110     Actor parent( actor.GetParent() );
 111     if ( parent )
 112     {
 113       parent.Remove( actor );
 114     }
 115
 116     return TouchEventFunctor::operator()( actor, touchEvent );
 117   }
 118 };
 119
 120 Integration::TouchEvent GenerateSingleTouch( TouchPoint::State state, Vector2 screenPosition )
 121 {
 122   Integration::TouchEvent touchEvent;
 123   touchEvent.points.push_back( TouchPoint ( 0, state, screenPosition.x, screenPosition.y ) );
 124   return touchEvent;
 125 }
 126
 127 } // anon namespace
 128
 129 ///////////////////////////////////////////////////////////////////////////////
 130
 131 int UtcDaliTouchNormalProcessing(void)
 132 {
 133   TestApplication application;
 134
 135   Actor actor = Actor::New();
 136   actor.SetSize(100.0f, 100.0f);
 137   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 138   Stage::GetCurrent().Add(actor);
 139
 140   // Render and notify
 141   application.SendNotification();
 142   application.Render();
 143
 144   // Connect to actor's touched signal
 145   SignalData data;
 146   TouchEventFunctor functor( data );
 147   actor.TouchedSignal().Connect( &application, functor );
 148
 149   Vector2 screenCoordinates( 10.0f, 10.0f );
 150   Vector2 localCoordinates;
 151   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 152
 153   // Emit a down signal
 154   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 155   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 156   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 157   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 158   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 159   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 160   data.Reset();
 161
 162   // Emit a motion signal
 163   screenCoordinates.x = screenCoordinates.y = 11.0f;
 164   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 165   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) );
 166   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 167   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 168   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 169   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 170   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 171   data.Reset();
 172
 173   // Emit an up signal
 174   screenCoordinates.x = screenCoordinates.y = 12.0f;
 175   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 176   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) );
 177   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 178   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 179   DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION );
 180   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 181   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 182   data.Reset();
 183
 184   // Emit a down signal where the actor is not present
 185   screenCoordinates.x = screenCoordinates.y = 200.0f;
 186   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 187   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 188   END_TEST;
 189 }
 190
 191 int UtcDaliTouchOutsideCameraNearFarPlanes(void)
 192 {
 193   TestApplication application;
 194
 195   Stage stage = Stage::GetCurrent();
 196   Vector2 stageSize = stage.GetSize();
 197
 198   Actor actor = Actor::New();
 199   actor.SetSize(100.0f, 100.0f);
 200   actor.SetAnchorPoint(AnchorPoint::CENTER);
 201   actor.SetParentOrigin(ParentOrigin::CENTER);
 202   stage.Add(actor);
 203
 204   // Render and notify
 205   application.SendNotification();
 206   application.Render();
 207
 208   // Get the camera's near and far planes
 209   RenderTaskList taskList = stage.GetRenderTaskList();
 210   Dali::RenderTask task = taskList.GetTask(0);
 211   CameraActor camera = task.GetCameraActor();
 212   float nearPlane = camera.GetNearClippingPlane();
 213   float farPlane = camera.GetFarClippingPlane();
 214
 215   // Calculate the current distance of the actor from the camera
 216   float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
 217   float distance = (stageSize.y * 0.5f) / tanHalfFov;
 218
 219   // Connect to actor's touched signal
 220   SignalData data;
 221   TouchEventFunctor functor( data );
 222   actor.TouchedSignal().Connect( &application, functor );
 223
 224   Vector2 screenCoordinates( stageSize.x * 0.5f, stageSize.y * 0.5f );
 225
 226   // Emit a down signal
 227   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 228   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 229   data.Reset();
 230
 231   // Emit a down signal where actor is just at the camera's near plane
 232   actor.SetZ(distance - nearPlane);
 233
 234   // Render and notify
 235   application.SendNotification();
 236   application.Render();
 237
 238   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 239   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 240   data.Reset();
 241
 242   // Emit a down signal where actor is closer than the camera's near plane
 243   actor.SetZ((distance - nearPlane) + 1.0f);
 244
 245   // Render and notify
 246   application.SendNotification();
 247   application.Render();
 248
 249   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 250   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 251   data.Reset();
 252
 253   // Emit a down signal where actor is just at the camera's far plane
 254   actor.SetZ(distance - farPlane);
 255
 256   // Render and notify
 257   application.SendNotification();
 258   application.Render();
 259
 260   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 261   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 262   data.Reset();
 263
 264   // Emit a down signal where actor is further than the camera's far plane
 265   actor.SetZ((distance - farPlane) - 1.0f);
 266
 267   // Render and notify
 268   application.SendNotification();
 269   application.Render();
 270
 271   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 272   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 273   data.Reset();
 274   END_TEST;
 275 }
 276
 277 int UtcDaliTouchEmitEmpty(void)
 278 {
 279   TestApplication application;
 280
 281   try
 282   {
 283     // Emit an empty TouchEvent
 284     Integration::TouchEvent event;
 285     application.ProcessEvent( event );
 286     tet_result( TET_FAIL );
 287   }
 288   catch ( Dali::DaliException& e )
 289   {
 290     DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION );
 291   }
 292   END_TEST;
 293 }
 294
 295 int UtcDaliTouchInterrupted(void)
 296 {
 297   TestApplication application;
 298
 299   Actor actor = Actor::New();
 300   actor.SetSize(100.0f, 100.0f);
 301   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 302   Stage::GetCurrent().Add(actor);
 303
 304   // Render and notify
 305   application.SendNotification();
 306   application.Render();
 307
 308   // Connect to actor's touched signal
 309   SignalData data;
 310   TouchEventFunctor functor( data );
 311   actor.TouchedSignal().Connect( &application, functor );
 312
 313   // Emit a down signal
 314   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 315   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 316   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 317   data.Reset();
 318
 319   // Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
 320   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
 321   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 322   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 323   data.Reset();
 324
 325   // Emit another interrupted signal, our signal handler should not be called.
 326   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 327   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 328   END_TEST;
 329 }
 330
 331 int UtcDaliTouchParentConsumer(void)
 332 {
 333   TestApplication application;
 334   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 335
 336   Actor actor = Actor::New();
 337   actor.SetSize(100.0f, 100.0f);
 338   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 339   Stage::GetCurrent().Add(actor);
 340
 341   // Render and notify
 342   application.SendNotification();
 343   application.Render();
 344
 345   // Connect to actor's touched signal
 346   SignalData data;
 347   TouchEventFunctor functor( data, false );
 348   actor.TouchedSignal().Connect( &application, functor );
 349
 350   // Connect to root actor's touched signal
 351   SignalData rootData;
 352   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 353   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 354
 355   Vector2 screenCoordinates( 10.0f, 10.0f );
 356   Vector2 actorCoordinates, rootCoordinates;
 357   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 358   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 359
 360   // Emit a down signal
 361   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 362   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 363   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 364   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 365   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 366   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 367   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 368   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 369   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 370   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 371   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 372   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 373   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 374   data.Reset();
 375   rootData.Reset();
 376
 377   // Emit a motion signal
 378   screenCoordinates.x = screenCoordinates.y = 11.0f;
 379   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 380   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 381   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) );
 382   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 383   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 384   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 385   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 386   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 387   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 388   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 389   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 390   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 391   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 392   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 393   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 394   data.Reset();
 395   rootData.Reset();
 396
 397   // Emit an up signal
 398   screenCoordinates.x = screenCoordinates.y = 12.0f;
 399   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 400   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 401   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) );
 402   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 403   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 404   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 405   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 406   DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION );
 407   DALI_TEST_EQUALS( TouchPoint::Up, rootData.touchEvent.points[0].state, TEST_LOCATION );
 408   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 409   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 410   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 411   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 412   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 413   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 414   data.Reset();
 415   rootData.Reset();
 416
 417   // Emit a down signal where the actor is not present, will hit the root actor though
 418   screenCoordinates.x = screenCoordinates.y = 200.0f;
 419   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 420   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 421   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 422   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 423   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 424   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 425   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 426   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 427   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 428   END_TEST;
 429 }
 430
 431 int UtcDaliTouchInterruptedParentConsumer(void)
 432 {
 433   TestApplication application;
 434   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 435
 436   Actor actor = Actor::New();
 437   actor.SetSize(100.0f, 100.0f);
 438   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 439   Stage::GetCurrent().Add(actor);
 440
 441   // Render and notify
 442   application.SendNotification();
 443   application.Render();
 444
 445   // Connect to actor's touched signal
 446   SignalData data;
 447   TouchEventFunctor functor( data, false );
 448   actor.TouchedSignal().Connect( &application, functor );
 449
 450   // Connect to root actor's touched signal
 451   SignalData rootData;
 452   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 453   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 454
 455   // Emit a down signal
 456   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 457   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 458   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 459   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 460   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 461   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 462   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 463   data.Reset();
 464   rootData.Reset();
 465
 466   // Emit an interrupted signal
 467   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 468   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 469   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 470   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 471   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 472   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 473   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 474   data.Reset();
 475   rootData.Reset();
 476
 477   // Emit another down signal
 478   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 479   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 480   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 481   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 482   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 483   data.Reset();
 484   rootData.Reset();
 485
 486   // Remove actor from Stage
 487   Stage::GetCurrent().Remove( actor );
 488   data.Reset();
 489   rootData.Reset();
 490
 491   // Render and notify
 492   application.SendNotification();
 493   application.Render();
 494
 495   // Emit an interrupted signal, only root actor's signal should be called.
 496   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
 497   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 498   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 499   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 500   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 501   data.Reset();
 502   rootData.Reset();
 503
 504   // Emit another interrupted state, none of the signal's should be called.
 505   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 506   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 507   DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION );
 508   END_TEST;
 509 }
 510
 511 int UtcDaliTouchLeave(void)
 512 {
 513   TestApplication application;
 514
 515   Actor actor = Actor::New();
 516   actor.SetSize(100.0f, 100.0f);
 517   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 518   Stage::GetCurrent().Add(actor);
 519
 520   // Render and notify
 521   application.SendNotification();
 522   application.Render();
 523
 524   // Connect to actor's touched signal
 525   SignalData data;
 526   TouchEventFunctor functor( data );
 527   actor.TouchedSignal().Connect( &application, functor );
 528
 529   // Set actor to require leave events
 530   actor.SetLeaveRequired( true );
 531
 532   // Emit a down signal
 533   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 534   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 535   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 536   data.Reset();
 537
 538   // Emit a motion signal outside of actor, should be signalled with a Leave
 539   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 540   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 541   DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION );
 542   data.Reset();
 543
 544   // Another motion outside of actor, no signalling
 545   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) );
 546   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 547   data.Reset();
 548
 549   // Another motion event inside actor, signalled with motion
 550   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) );
 551   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 552   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 553   data.Reset();
 554
 555   // We do not want to listen to leave events anymore
 556   actor.SetLeaveRequired( false );
 557
 558   // Another motion event outside of actor, no signalling
 559   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 560   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 561   data.Reset();
 562   END_TEST;
 563 }
 564
 565 int UtcDaliTouchLeaveParentConsumer(void)
 566 {
 567   TestApplication application;
 568   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 569
 570   Actor actor = Actor::New();
 571   actor.SetSize(100.0f, 100.0f);
 572   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 573   Stage::GetCurrent().Add(actor);
 574
 575   // Render and notify
 576   application.SendNotification();
 577   application.Render();
 578
 579   // Connect to actor's touched signal
 580   SignalData data;
 581   TouchEventFunctor functor( data, false );
 582   actor.TouchedSignal().Connect( &application, functor );
 583
 584   // Connect to root actor's touched signal
 585   SignalData rootData;
 586   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 587   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 588
 589   // Set actor to require leave events
 590   actor.SetLeaveRequired( true );
 591   rootActor.SetLeaveRequired( true );
 592
 593   // Emit a down signal
 594   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 595   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 596   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 597   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 598   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 599   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 600   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 601   data.Reset();
 602   rootData.Reset();
 603
 604   // Emit a motion signal outside of actor, should be signalled with a Leave
 605   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 606   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 607   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 608   DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION );
 609   DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION );
 610   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 611   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 612   data.Reset();
 613   rootData.Reset();
 614
 615   // Another motion outside of actor, only rootActor signalled
 616   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) );
 617   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 618   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 619   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 620   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 621   data.Reset();
 622   rootData.Reset();
 623
 624   // Another motion event inside actor, signalled with motion
 625   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) );
 626   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 627   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 628   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 629   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 630   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 631   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 632   data.Reset();
 633   rootData.Reset();
 634
 635   // We do not want to listen to leave events of actor anymore
 636   actor.SetLeaveRequired( false );
 637
 638   // Another motion event outside of root actor, only root signalled
 639   Vector2 stageSize( Stage::GetCurrent().GetSize() );
 640   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( stageSize.width + 10.0f, stageSize.height + 10.0f )) );
 641   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 642   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 643   DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION );
 644   END_TEST;
 645 }
 646
 647 int UtcDaliTouchActorBecomesInsensitive(void)
 648 {
 649   TestApplication application;
 650
 651   Actor actor = Actor::New();
 652   actor.SetSize(100.0f, 100.0f);
 653   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 654   Stage::GetCurrent().Add(actor);
 655
 656   // Render and notify
 657   application.SendNotification();
 658   application.Render();
 659
 660   // Connect to actor's touched signal
 661   SignalData data;
 662   TouchEventFunctor functor( data );
 663   actor.TouchedSignal().Connect( &application, functor );
 664
 665   // Emit a down signal
 666   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 667   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 668   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 669   data.Reset();
 670
 671   // Change actor to insensitive
 672   actor.SetSensitive( false );
 673
 674   // Emit a motion signal, signalled with an interrupted
 675   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 676   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 677   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 678   data.Reset();
 679   END_TEST;
 680 }
 681
 682 int UtcDaliTouchActorBecomesInsensitiveParentConsumer(void)
 683 {
 684   TestApplication application;
 685   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 686
 687   Actor actor = Actor::New();
 688   actor.SetSize(100.0f, 100.0f);
 689   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 690   Stage::GetCurrent().Add(actor);
 691
 692   // Render and notify
 693   application.SendNotification();
 694   application.Render();
 695
 696   // Connect to actor's touched signal
 697   SignalData data;
 698   TouchEventFunctor functor( data, false );
 699   actor.TouchedSignal().Connect( &application, functor );
 700
 701   // Connect to root actor's touched signal
 702   SignalData rootData;
 703   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 704   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 705
 706   // Emit a down signal
 707   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 708   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 709   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 710   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 711   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 712   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 713   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 714   data.Reset();
 715   rootData.Reset();
 716
 717   // Render and notify
 718   application.SendNotification();
 719   application.Render();
 720
 721   // Make root actor insensitive
 722   rootActor.SetSensitive( false );
 723
 724   // Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor)
 725   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 726   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 727   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 728   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 729   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 730   END_TEST;
 731 }
 732
 733 int UtcDaliTouchMultipleLayers(void)
 734 {
 735   TestApplication application;
 736   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 737
 738   // Connect to actor's touched signal
 739   SignalData data;
 740   TouchEventFunctor functor( data );
 741
 742   Layer layer1 ( Layer::New() );
 743   layer1.SetSize(100.0f, 100.0f);
 744   layer1.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 745   Stage::GetCurrent().Add( layer1 );
 746
 747   Actor actor1 ( Actor::New() );
 748   actor1.SetSize( 100.0f, 100.0f );
 749   actor1.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 750   actor1.SetZ( 1.0f ); // Should hit actor1 in this layer
 751   layer1.Add( actor1 );
 752
 753   // Render and notify
 754   application.SendNotification();
 755   application.Render();
 756
 757   // Connect to layer1 and actor1
 758   layer1.TouchedSignal().Connect( &application, functor );
 759   actor1.TouchedSignal().Connect( &application, functor );
 760
 761   // Hit in hittable area, actor1 should be hit
 762   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 763   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 764   DALI_TEST_CHECK( data.touchedActor == actor1 );
 765   data.Reset();
 766
 767   // Make layer1 insensitive, nothing should be hit
 768   layer1.SetSensitive( false );
 769   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 770   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 771   data.Reset();
 772
 773   // Make layer1 sensitive again, again actor1 will be hit
 774   layer1.SetSensitive( true );
 775   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 776   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 777   DALI_TEST_CHECK( data.touchedActor == actor1 );
 778   data.Reset();
 779
 780   // Make rootActor insensitive, nothing should be hit
 781   rootActor.SetSensitive( false );
 782   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 783   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 784   data.Reset();
 785
 786   // Make rootActor sensitive
 787   rootActor.SetSensitive( true );
 788
 789   // Add another layer
 790   Layer layer2 ( Layer::New() );
 791   layer2.SetSize(100.0f, 100.0f );
 792   layer2.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 793   layer2.SetZ( 10.0f ); // Should hit layer2 in this layer rather than actor2
 794   Stage::GetCurrent().Add( layer2 );
 795
 796   Actor actor2 ( Actor::New() );
 797   actor2.SetSize(100.0f, 100.0f);
 798   actor2.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 799   layer2.Add( actor2 );
 800
 801   // Render and notify
 802   application.SendNotification();
 803   application.Render();
 804
 805   // Connect to layer2 and actor2
 806   layer2.TouchedSignal().Connect( &application, functor );
 807   actor2.TouchedSignal().Connect( &application, functor );
 808
 809   // Emit an event, should hit layer2
 810   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 811   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 812   //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
 813   data.Reset();
 814
 815   // Make layer2 insensitive, should hit actor1
 816   layer2.SetSensitive( false );
 817   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 818   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 819   DALI_TEST_CHECK( data.touchedActor == actor1 );
 820   data.Reset();
 821
 822   // Make layer2 sensitive again, should hit layer2
 823   layer2.SetSensitive( true );
 824   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 825   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 826   //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
 827   data.Reset();
 828
 829   // Make layer2 invisible, render and notify
 830   layer2.SetVisible( false );
 831   application.SendNotification();
 832   application.Render();
 833
 834   // Should hit actor1
 835   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 836   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 837   DALI_TEST_CHECK( data.touchedActor == actor1 );
 838   data.Reset();
 839
 840   // Make rootActor invisible, render and notify
 841   rootActor.SetVisible( false );
 842   application.SendNotification();
 843   application.Render();
 844
 845   // Should not hit anything
 846   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 847   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 848   data.Reset();
 849   END_TEST;
 850 }
 851
 852 int UtcDaliTouchMultipleRenderTasks(void)
 853 {
 854   TestApplication application;
 855   Stage stage ( Stage::GetCurrent() );
 856   Vector2 stageSize ( stage.GetSize() );
 857
 858   Actor actor = Actor::New();
 859   actor.SetSize(100.0f, 100.0f);
 860   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 861   stage.Add(actor);
 862
 863   // Create render task
 864   Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
 865   RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() );
 866   renderTask.SetViewport( viewport );
 867   renderTask.SetInputEnabled( true );
 868
 869   // Render and notify
 870   application.SendNotification();
 871   application.Render();
 872
 873   // Connect to actor's touched signal
 874   SignalData data;
 875   TouchEventFunctor functor( data );
 876   actor.TouchedSignal().Connect( &application, functor );
 877
 878   // Emit a down signal
 879   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 880   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 881   data.Reset();
 882
 883   // Ensure renderTask actor can be hit too.
 884   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 885   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 886   data.Reset();
 887
 888   // Disable input on renderTask, should not be hittable
 889   renderTask.SetInputEnabled( false );
 890   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 891   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 892   data.Reset();
 893   END_TEST;
 894 }
 895
 896 int UtcDaliTouchMultipleRenderTasksWithChildLayer(void)
 897 {
 898   TestApplication application;
 899   Stage stage ( Stage::GetCurrent() );
 900   Vector2 stageSize ( stage.GetSize() );
 901
 902   Actor actor = Actor::New();
 903   actor.SetSize(100.0f, 100.0f);
 904   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 905   stage.Add(actor);
 906
 907   Layer layer = Layer::New();
 908   layer.SetSize(100.0f, 100.0f);
 909   layer.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 910   actor.Add(layer);
 911
 912   // Create render task
 913   Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
 914   RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() );
 915   renderTask.SetViewport( viewport );
 916   renderTask.SetInputEnabled( true );
 917   renderTask.SetSourceActor( actor );
 918
 919   // Render and notify
 920   application.SendNotification();
 921   application.Render();
 922
 923   // Connect to layer's touched signal
 924   SignalData data;
 925   TouchEventFunctor functor( data );
 926   actor.TouchedSignal().Connect( &application, functor );
 927   layer.TouchedSignal().Connect( &application, functor );
 928
 929   // Emit a down signal
 930   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 931   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 932   data.Reset();
 933
 934   // Ensure renderTask actor can be hit too.
 935   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 936   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 937   data.Reset();
 938
 939   // Disable input on renderTask, should not be hittable
 940   renderTask.SetInputEnabled( false );
 941   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 942   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 943   data.Reset();
 944   END_TEST;
 945 }
 946
 947 int UtcDaliTouchOffscreenRenderTasks(void)
 948 {
 949   TestApplication application;
 950   Stage stage ( Stage::GetCurrent() );
 951   Vector2 stageSize ( stage.GetSize() );
 952
 953   // FrameBufferImage for offscreen RenderTask
 954   FrameBufferImage frameBufferImage( FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 ) );
 955
 956   // Create an image actor to display the FrameBufferImage
 957   ImageActor imageActor ( ImageActor::New( frameBufferImage ) );
 958   imageActor.SetParentOrigin(ParentOrigin::CENTER);
 959   imageActor.SetSize( stageSize.x, stageSize.y );
 960   imageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
 961   stage.Add( imageActor );
 962
 963   Actor actor = Actor::New();
 964   actor.SetSize(100.0f, 100.0f);
 965   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 966   stage.Add( actor );
 967   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects
 968
 969   stage.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
 970
 971   // Create a RenderTask
 972   RenderTask renderTask = stage.GetRenderTaskList().CreateTask();
 973   renderTask.SetSourceActor( actor );
 974   renderTask.SetTargetFrameBuffer( frameBufferImage );
 975   renderTask.SetInputEnabled( true );
 976
 977   // Create another RenderTask
 978   RenderTask renderTask2( stage.GetRenderTaskList().CreateTask() );
 979   renderTask2.SetInputEnabled( true );
 980
 981   // Render and notify
 982   application.SendNotification();
 983   application.Render();
 984
 985   // Connect to actor's touched signal
 986   SignalData data;
 987   TouchEventFunctor functor( data );
 988   actor.TouchedSignal().Connect( &application, functor );
 989
 990   // Emit a down signal
 991   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 992   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 993   data.Reset();
 994   END_TEST;
 995 }
 996
 997 int UtcDaliTouchMultipleRenderableActors(void)
 998 {
 999   TestApplication application;
1000   Stage stage ( Stage::GetCurrent() );
1001   Vector2 stageSize ( stage.GetSize() );
1002
1003   Actor parent = ImageActor::New();
1004   parent.SetRelayoutEnabled( false );
1005   parent.SetSize(100.0f, 100.0f);
1006   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1007   stage.Add(parent);
1008
1009   Actor actor = ImageActor::New();
1010   actor.SetRelayoutEnabled( false );
1011   actor.SetSize(100.0f, 100.0f);
1012   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1013   parent.Add(actor);
1014
1015   // Render and notify
1016   application.SendNotification();
1017   application.Render();
1018
1019   // Connect to layer's touched signal
1020   SignalData data;
1021   TouchEventFunctor functor( data );
1022   parent.TouchedSignal().Connect( &application, functor );
1023   actor.TouchedSignal().Connect( &application, functor );
1024
1025   // Emit a down signal
1026   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1027   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1028   DALI_TEST_CHECK( actor == data.touchedActor );
1029   END_TEST;
1030 }
1031
1032 int UtcDaliTouchActorRemovedInSignal(void)
1033 {
1034   TestApplication application;
1035
1036   Actor actor = Actor::New();
1037   actor.SetSize(100.0f, 100.0f);
1038   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1039   Stage::GetCurrent().Add(actor);
1040
1041   // Render and notify
1042   application.SendNotification();
1043   application.Render();
1044
1045   // Connect to actor's touched signal
1046   SignalData data;
1047   RemoveActorFunctor functor( data );
1048   actor.TouchedSignal().Connect( &application, functor );
1049
1050   // Register for leave events
1051   actor.SetLeaveRequired( true );
1052
1053   // Emit a down signal
1054   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1055   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1056   data.Reset();
1057
1058   // Re-add, render and notify
1059   Stage::GetCurrent().Add(actor);
1060   application.SendNotification();
1061   application.Render();
1062
1063   // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1064   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1065   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1066   data.Reset();
1067
1068   // Emit a down signal
1069   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1070   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1071   data.Reset();
1072
1073   // Render and notify
1074   application.SendNotification();
1075   application.Render();
1076
1077   // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1078   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1079   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1080   data.Reset();
1081
1082   // Re-add actor back to stage, render and notify
1083   Stage::GetCurrent().Add(actor);
1084   application.SendNotification();
1085   application.Render();
1086
1087   // Emit another down event
1088   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1089   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1090   data.Reset();
1091
1092   // Completely delete the actor
1093   actor.Reset();
1094
1095   // Emit event, should not crash and should not receive an event.
1096   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1097   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1098   END_TEST;
1099 }
1100
1101 int UtcDaliTouchActorSignalNotConsumed(void)
1102 {
1103   TestApplication application;
1104
1105   Actor actor = Actor::New();
1106   actor.SetSize(100.0f, 100.0f);
1107   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1108   Stage::GetCurrent().Add(actor);
1109
1110   // Render and notify
1111   application.SendNotification();
1112   application.Render();
1113
1114   // Connect to actor's touched signal
1115   SignalData data;
1116   TouchEventFunctor functor( data, false );
1117   actor.TouchedSignal().Connect( &application, functor );
1118
1119   // Emit a down signal
1120   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1121   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1122   END_TEST;
1123 }
1124
1125 int UtcDaliTouchActorUnStaged(void)
1126 {
1127   TestApplication application;
1128
1129   Actor actor = Actor::New();
1130   actor.SetSize(100.0f, 100.0f);
1131   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1132   Stage::GetCurrent().Add(actor);
1133
1134   // Render and notify
1135   application.SendNotification();
1136   application.Render();
1137
1138   // Connect to actor's touched signal
1139   SignalData data;
1140   TouchEventFunctor functor( data );
1141   actor.TouchedSignal().Connect( &application, functor );
1142
1143   // Emit a down signal
1144   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1145   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1146   data.Reset();
1147
1148   // Remove actor from stage
1149   Stage::GetCurrent().Remove( actor );
1150   data.Reset();
1151
1152   // Render and notify
1153   application.SendNotification();
1154   application.Render();
1155
1156   // Emit a move at the same point, we should not be signalled.
1157   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) );
1158   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1159   data.Reset();
1160   END_TEST;
1161 }
1162
1163 int UtcDaliTouchSystemOverlayActor(void)
1164 {
1165   TestApplication application;
1166   Dali::Integration::Core& core( application.GetCore() );
1167   Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1168   systemOverlay.GetOverlayRenderTasks().CreateTask();
1169
1170   // Create an actor and add it to the system overlay.
1171   Actor systemActor = Actor::New();
1172   systemActor.SetSize(100.0f, 100.0f);
1173   systemActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1174   systemOverlay.Add( systemActor );
1175
1176   // Create an actor and add it to the stage as per normal, same position and size as systemActor
1177   Actor actor = Actor::New();
1178   actor.SetSize(100.0f, 100.0f);
1179   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1180   Stage::GetCurrent().Add(actor);
1181
1182   // Connect to the touch signals.
1183   SignalData data;
1184   TouchEventFunctor functor( data );
1185   systemActor.TouchedSignal().Connect( &application, functor );
1186   actor.TouchedSignal().Connect( &application, functor );
1187
1188   // Render and notify
1189   application.SendNotification();
1190   application.Render();
1191
1192   // Emit a down signal, the system overlay is drawn last so is at the top, should hit the systemActor.
1193   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1194   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1195   DALI_TEST_CHECK( systemActor == data.touchedActor );
1196   END_TEST;
1197 }
1198
1199 int UtcDaliTouchLayerConsumesTouch(void)
1200 {
1201   TestApplication application;
1202
1203   Actor actor = Actor::New();
1204   actor.SetSize(100.0f, 100.0f);
1205   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1206   Stage::GetCurrent().Add(actor);
1207
1208   // Render and notify
1209   application.SendNotification();
1210   application.Render();
1211
1212   // Connect to actor's touched signal
1213   SignalData data;
1214   TouchEventFunctor functor( data );
1215   actor.TouchedSignal().Connect( &application, functor );
1216
1217   // Add a layer to overlap the actor
1218   Layer layer = Layer::New();
1219   layer.SetSize(100.0f, 100.0f);
1220   layer.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1221   Stage::GetCurrent().Add( layer );
1222   layer.RaiseToTop();
1223
1224   // Render and notify
1225   application.SendNotification();
1226   application.Render();
1227
1228   // Emit a few touch signals
1229   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1230   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, Vector2( 10.0f, 10.0f ) ) );
1231   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1232   data.Reset();
1233
1234   // Set layer to consume all touch
1235   layer.SetTouchConsumed( true );
1236
1237   // Render and notify
1238   application.SendNotification();
1239   application.Render();
1240
1241   // Emit the same signals again, should not receive
1242   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1243   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, Vector2( 10.0f, 10.0f ) ) );
1244   DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1245   data.Reset();
1246
1247   END_TEST;
1248 }
1249
1250 int UtcDaliTouchLeaveActorReadded(void)
1251 {
1252   TestApplication application;
1253   Stage stage = Stage::GetCurrent();
1254
1255   Actor actor = Actor::New();
1256   actor.SetSize(100.0f, 100.0f);
1257   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1258   stage.Add(actor);
1259
1260   // Set actor to receive touch-events
1261   actor.SetLeaveRequired( true );
1262
1263   // Render and notify
1264   application.SendNotification();
1265   application.Render();
1266
1267   // Connect to actor's touched signal
1268   SignalData data;
1269   TouchEventFunctor functor( data );
1270   actor.TouchedSignal().Connect( &application, functor );
1271
1272   // Emit a down and motion
1273   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1274   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 11.0f, 10.0f ) ) );
1275   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1276   data.Reset();
1277
1278   // Remove actor from stage and add again
1279   stage.Remove( actor );
1280   stage.Add( actor );
1281
1282   // Emit a motion within the actor's bounds
1283   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 12.0f, 10.0f ) ) );
1284   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1285   data.Reset();
1286
1287   // Emit a motion outside the actor's bounds
1288   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 200.0f, 200.0f ) ) );
1289   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1290   DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION );
1291   data.Reset();
1292
1293   END_TEST;
1294 }
1295
1296 int UtcDaliTouchStencil(void)
1297 {
1298   TestApplication application;
1299   Stage stage = Stage::GetCurrent();
1300
1301   TextActor actor = TextActor::New();
1302   actor.SetSize(100.0f, 100.0f);
1303   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1304   stage.Add(actor);
1305
1306   Actor stencil = Actor::New();
1307   stencil.SetSize(50.0f, 50.0f);
1308   stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1309   stencil.SetDrawMode( DrawMode::STENCIL );
1310   stage.Add(stencil);
1311
1312   // Render and notify
1313   application.SendNotification();
1314   application.Render();
1315
1316   // Connect to actor's touched signal
1317   SignalData data;
1318   TouchEventFunctor functor( data );
1319   actor.TouchedSignal().Connect( &application, functor );
1320
1321   // Emit an event within stencil area
1322   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1323   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1324   data.Reset();
1325
1326   // Emit an event outside the stencil area but within the actor area
1327   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) );
1328   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1329   data.Reset();
1330
1331   END_TEST;
1332 }
1333
1334 int UtcDaliTouchStencilInActorHierarchy(void)
1335 {
1336   TestApplication application;
1337   Stage stage = Stage::GetCurrent();
1338
1339   TextActor parent = TextActor::New();
1340   parent.SetSize(100.0f, 100.0f);
1341   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1342   stage.Add(parent);
1343
1344   TextActor child = TextActor::New();
1345   child.SetSize(25.0f, 25.0f);
1346   child.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1347   parent.Add(child);
1348
1349   Actor stencil = Actor::New();
1350   stencil.SetSize(50.0f, 50.0f);
1351   stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1352   stencil.SetDrawMode( DrawMode::STENCIL );
1353   stage.Add(stencil);
1354
1355   // Render and notify
1356   application.SendNotification();
1357   application.Render();
1358
1359   // Connect to touch signals
1360   SignalData parentData;
1361   parent.TouchedSignal().Connect( &application, TouchEventFunctor(parentData) );
1362   SignalData childData;
1363   child.TouchedSignal().Connect( &application, TouchEventFunctor(childData) );
1364
1365   // Emit an event within stencil area
1366   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1367   DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
1368   DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION );
1369   parentData.Reset();
1370   childData.Reset();
1371
1372   // Emit an event outside child area and within stencil area
1373   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 40.0f, 40.0f ) ) );
1374   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1375   DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
1376   parentData.Reset();
1377   childData.Reset();
1378
1379   // Emit an event outside stencil are but within parent area
1380   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 60.0f, 60.0f ) ) );
1381   DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
1382   DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
1383   parentData.Reset();
1384   childData.Reset();
1385
1386   // Readd actor (so that stencil is the first child)
1387   stage.Remove(parent);
1388   application.SendNotification();
1389   application.Render();
1390   stage.Add(parent);
1391   application.SendNotification();
1392   application.Render();
1393
1394   // Redo hit in same area...
1395
1396   // Emit an event within stencil area
1397   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) );
1398   DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
1399   DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION );
1400   parentData.Reset();
1401   childData.Reset();
1402
1403   // Emit an event outside child area and within stencil area
1404   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 40.0f, 40.0f ) ) );
1405   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1406   DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
1407   parentData.Reset();
1408   childData.Reset();
1409
1410   // Emit an event outside stencil are but within parent area
1411   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 60.0f, 60.0f ) ) );
1412   DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
1413   DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
1414   parentData.Reset();
1415   childData.Reset();
1416
1417   END_TEST;
1418 }
1419
1420 int UtcDaliTouchMultipleStencils(void)
1421 {
1422   TestApplication application;
1423   Stage stage = Stage::GetCurrent();
1424
1425   TextActor actor = TextActor::New();
1426   actor.SetSize(100.0f, 100.0f);
1427   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1428   stage.Add(actor);
1429
1430   Actor stencil = Actor::New();
1431   stencil.SetSize(50.0f, 50.0f);
1432   stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1433   stencil.SetDrawMode( DrawMode::STENCIL );
1434   stage.Add(stencil);
1435
1436   Actor stencil2 = Actor::New();
1437   stencil2.SetSize(50.0f, 50.0f);
1438   stencil2.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1439   stencil2.SetDrawMode( DrawMode::STENCIL );
1440   stencil2.SetPosition(50.0f, 50.0f);
1441   stage.Add(stencil2);
1442
1443   // Render and notify
1444   application.SendNotification();
1445   application.Render();
1446
1447   // Connect to actor's touched signal
1448   SignalData data;
1449   TouchEventFunctor functor( data );
1450   actor.TouchedSignal().Connect( &application, functor );
1451
1452   // Emit an event within stencil area
1453   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1454   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1455   data.Reset();
1456
1457   // Emit an event inside the second stencil area
1458   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) );
1459   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1460   data.Reset();
1461
1462   // Emit an event outside both stencil areas but within the actor area
1463   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 60.0f ) ) );
1464   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1465   data.Reset();
1466
1467   END_TEST;
1468 }
1469
1470 int UtcDaliTouchStencilNonRenderableActor(void)
1471 {
1472   TestApplication application;
1473   Stage stage = Stage::GetCurrent();
1474
1475   Actor actor = Actor::New();
1476   actor.SetSize(100.0f, 100.0f);
1477   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1478   stage.Add(actor);
1479
1480   Actor stencil = Actor::New();
1481   stencil.SetSize(50.0f, 50.0f);
1482   stencil.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1483   stencil.SetDrawMode( DrawMode::STENCIL );
1484   stage.Add(stencil);
1485
1486   // Render and notify
1487   application.SendNotification();
1488   application.Render();
1489
1490   // Connect to actor's touched signal
1491   SignalData data;
1492   TouchEventFunctor functor( data );
1493   actor.TouchedSignal().Connect( &application, functor );
1494
1495   // Emit an event within stencil area
1496   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1497   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1498   data.Reset();
1499
1500   // Emit an event outside the stencil area but within the actor area, we should have a hit!
1501   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 60.0f, 60.0f ) ) );
1502   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1503   data.Reset();
1504
1505   END_TEST;
1506 }
1507
1508 int UtcDaliTouchActorUnstaged(void)
1509 {
1510   TestApplication application;
1511
1512   Actor actor = Actor::New();
1513   actor.SetSize(100.0f, 100.0f);
1514   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1515   Stage::GetCurrent().Add(actor);
1516
1517   // Render and notify
1518   application.SendNotification();
1519   application.Render();
1520
1521   // Connect to actor's touched signal
1522   SignalData data;
1523   TouchEventFunctor functor( data );
1524   actor.TouchedSignal().Connect( &application, functor );
1525
1526   // Emit a down signal
1527   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1528   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1529   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
1530   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
1531   data.Reset();
1532
1533   // Render and notify
1534   application.SendNotification();
1535   application.Render();
1536
1537   // Unparent the actor
1538   actor.Unparent();
1539
1540   // Should receive an interrupted event
1541   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1542   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
1543   END_TEST;
1544 }
1545
1546 int UtcDaliTouchParentUnstaged(void)
1547 {
1548   TestApplication application;
1549
1550   Actor parent = Actor::New();
1551   parent.SetSize(100.0f, 100.0f);
1552   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1553   Stage::GetCurrent().Add(parent);
1554
1555   Actor actor = Actor::New();
1556   actor.SetSize(100.0f, 100.0f);
1557   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1558   parent.Add(actor);
1559
1560   // Render and notify
1561   application.SendNotification();
1562   application.Render();
1563
1564   // Connect to actor's touched signal
1565   SignalData data;
1566   TouchEventFunctor functor( data );
1567   actor.TouchedSignal().Connect( &application, functor );
1568
1569   // Emit a down signal
1570   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1571   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1572   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
1573   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
1574   data.Reset();
1575
1576   // Render and notify
1577   application.SendNotification();
1578   application.Render();
1579
1580   // Unparent the parent of the touchable actor
1581   parent.Unparent();
1582
1583   // Should receive an interrupted event
1584   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1585   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
1586   END_TEST;
1587 }
1588
1589 int UtcDaliTouchActorUnstagedDifferentConsumer(void)
1590 {
1591   TestApplication application;
1592
1593   Actor parent = Actor::New();
1594   parent.SetSize(100.0f, 100.0f);
1595   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1596   Stage::GetCurrent().Add(parent);
1597
1598   Actor actor = Actor::New();
1599   actor.SetSize(100.0f, 100.0f);
1600   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1601   parent.Add(actor);
1602
1603   // Render and notify
1604   application.SendNotification();
1605   application.Render();
1606
1607   // Connect to actor's touched signal
1608   SignalData data;
1609   TouchEventFunctor functor( data, false /* Do not consume */ );
1610   actor.TouchedSignal().Connect( &application, functor );
1611
1612   // Connect to parent's touched signal
1613   SignalData parentData;
1614   TouchEventFunctor parentFunctor( parentData );
1615   parent.TouchedSignal().Connect( &application, parentFunctor );
1616
1617   // Emit a down signal
1618   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1619   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1620   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
1621   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
1622   DALI_TEST_CHECK( actor == data.touchedActor );
1623   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1624   DALI_TEST_EQUALS( TouchPoint::Down, parentData.touchEvent.points[0].state, TEST_LOCATION );
1625   DALI_TEST_CHECK( actor == parentData.touchEvent.points[0].hitActor );
1626   DALI_TEST_CHECK( parent == parentData.touchedActor );
1627   data.Reset();
1628   parentData.Reset();
1629
1630   // Render and notify
1631   application.SendNotification();
1632   application.Render();
1633
1634   // Unparent the actor
1635   actor.Unparent();
1636
1637   // Should receive an interrupted event for both actor & parent
1638   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1639   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
1640   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1641   DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION );
1642   data.Reset();
1643   parentData.Reset();
1644
1645   // Readd actor to parent
1646   parent.Add(actor);
1647
1648   // Render and notify
1649   application.SendNotification();
1650   application.Render();
1651
1652   // Emit a motion signal
1653   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) );
1654   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1655   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1656   data.Reset();
1657   parentData.Reset();
1658
1659   // Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer
1660   SignalData secondData;
1661   TouchEventFunctor secondFunctor( secondData /* Consume */ );
1662   actor.TouchedSignal().Connect( &application, secondFunctor );
1663
1664   // Unparent the actor
1665   actor.Unparent();
1666
1667   // Should receive an interrupted event for both actor functors & the parent as well as it was last consumer
1668   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1669   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
1670   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1671   DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION );
1672   DALI_TEST_EQUALS( true, secondData.functorCalled, TEST_LOCATION );
1673   DALI_TEST_EQUALS( TouchPoint::Interrupted, secondData.touchEvent.points[0].state, TEST_LOCATION );
1674   data.Reset();
1675   parentData.Reset();
1676   secondData.Reset();
1677
1678   END_TEST;
1679 }
1680
1681 int UtcDaliTouchInterruptedDifferentConsumer(void)
1682 {
1683   TestApplication application;
1684   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
1685
1686   Actor parent = Actor::New();
1687   parent.SetSize(100.0f, 100.0f);
1688   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1689   Stage::GetCurrent().Add(parent);
1690
1691   Actor actor = Actor::New();
1692   actor.SetSize(100.0f, 100.0f);
1693   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1694   parent.Add(actor);
1695
1696   // Render and notify
1697   application.SendNotification();
1698   application.Render();
1699
1700   // Connect to actor's touched signal
1701   SignalData data;
1702   TouchEventFunctor functor( data, false /* Do not consume */ );
1703   actor.TouchedSignal().Connect( &application, functor );
1704
1705   // Connect to parent's touched signal
1706   SignalData parentData;
1707   TouchEventFunctor parentFunctor( parentData, false /* Do not consume */ );
1708   parent.TouchedSignal().Connect( &application, parentFunctor );
1709
1710   // Connect to root's touched signal and consume
1711   SignalData rootData;
1712   TouchEventFunctor rootFunctor( rootData );
1713   rootActor.TouchedSignal().Connect( &application, rootFunctor );
1714
1715   // Emit a down signal
1716   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1717   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1718   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
1719   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
1720   DALI_TEST_CHECK( actor == data.touchedActor );
1721   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1722   DALI_TEST_EQUALS( TouchPoint::Down, parentData.touchEvent.points[0].state, TEST_LOCATION );
1723   DALI_TEST_CHECK( actor == parentData.touchEvent.points[0].hitActor );
1724   DALI_TEST_CHECK( parent == parentData.touchedActor );
1725   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
1726   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
1727   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
1728   DALI_TEST_CHECK( rootActor == rootData.touchedActor );
1729   data.Reset();
1730   parentData.Reset();
1731   rootData.Reset();
1732
1733   // Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer
1734   SignalData secondData;
1735   TouchEventFunctor secondFunctor( secondData /* Consume */ );
1736   parent.TouchedSignal().Connect( &application, secondFunctor );
1737
1738   // Emit an interrupted signal, all three should STILL be called
1739   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 10.0f, 10.0f ) ) );
1740   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1741   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
1742   DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1743   DALI_TEST_EQUALS( TouchPoint::Interrupted, parentData.touchEvent.points[0].state, TEST_LOCATION );
1744   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
1745   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
1746   data.Reset();
1747   parentData.Reset();
1748   rootData.Reset();
1749
1750   END_TEST;
1751 }