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

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 #include <iostream>
  18
  19 #include <stdlib.h>
  20 #include <dali/dali.h>
  21 #include <dali/integration-api/events/touch-event-integ.h>
  22 #include <dali/integration-api/system-overlay.h>
  23 #include <dali-test-suite-utils.h>
  24
  25 using namespace Dali;
  26
  27 void utc_dali_touch_processing_startup(void)
  28 {
  29   test_return_value = TET_UNDEF;
  30 }
  31
  32 void utc_dali_touch_processing_cleanup(void)
  33 {
  34   test_return_value = TET_PASS;
  35 }
  36
  37 ///////////////////////////////////////////////////////////////////////////////
  38
  39 namespace
  40 {
  41
  42 // Stores data that is populated in the callback and will be read by the TET cases
  43 struct SignalData
  44 {
  45   SignalData()
  46   : functorCalled( false ),
  47     touchEvent(),
  48     touchedActor()
  49   {
  50   }
  51
  52   void Reset()
  53   {
  54     functorCalled = false;
  55
  56     touchEvent.time = 0u;
  57     touchEvent.points.clear();
  58
  59     touchedActor = NULL;
  60   }
  61
  62   bool functorCalled;
  63   TouchEvent touchEvent;
  64   Actor touchedActor;
  65 };
  66
  67 // Functor that sets the data when called
  68 struct TouchEventFunctor
  69 {
  70   /**
  71    * Constructor.
  72    * @param[in]  data         Reference to the data to store callback information.
  73    * @param[in]  returnValue  What the functor should return.
  74    */
  75   TouchEventFunctor( SignalData& data, bool returnValue = true )
  76   : signalData( data ),
  77     returnValue( returnValue )
  78   {
  79   }
  80
  81   bool operator()( Actor actor, const TouchEvent& touchEvent )
  82   {
  83     signalData.functorCalled = true;
  84     signalData.touchedActor = actor;
  85     signalData.touchEvent = touchEvent;
  86
  87     return returnValue;
  88   }
  89
  90   SignalData& signalData;
  91   bool returnValue;
  92 };
  93
  94 // Functor that removes the actor when called.
  95 struct RemoveActorFunctor : public TouchEventFunctor
  96 {
  97   /**
  98    * Constructor.
  99    * @param[in]  data         Reference to the data to store callback information.
 100    * @param[in]  returnValue  What the functor should return.
 101    */
 102   RemoveActorFunctor( SignalData& data, bool returnValue = true )
 103   : TouchEventFunctor( data, returnValue )
 104   {
 105   }
 106
 107   bool operator()( Actor actor, const TouchEvent& touchEvent )
 108   {
 109     Actor parent( actor.GetParent() );
 110     if ( parent )
 111     {
 112       parent.Remove( actor );
 113     }
 114
 115     return TouchEventFunctor::operator()( actor, touchEvent );
 116   }
 117 };
 118
 119 Integration::TouchEvent GenerateSingleTouch( TouchPoint::State state, Vector2 screenPosition )
 120 {
 121   Integration::TouchEvent touchEvent;
 122   touchEvent.points.push_back( TouchPoint ( 0, state, screenPosition.x, screenPosition.y ) );
 123   return touchEvent;
 124 }
 125
 126 } // anon namespace
 127
 128 ///////////////////////////////////////////////////////////////////////////////
 129
 130 int UtcDaliTouchNormalProcessing(void)
 131 {
 132   TestApplication application;
 133
 134   Actor actor = Actor::New();
 135   actor.SetSize(100.0f, 100.0f);
 136   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 137   Stage::GetCurrent().Add(actor);
 138
 139   // Render and notify
 140   application.SendNotification();
 141   application.Render();
 142
 143   // Connect to actor's touched signal
 144   SignalData data;
 145   TouchEventFunctor functor( data );
 146   actor.TouchedSignal().Connect( &application, functor );
 147
 148   Vector2 screenCoordinates( 10.0f, 10.0f );
 149   Vector2 localCoordinates;
 150   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 151
 152   // Emit a down signal
 153   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 154   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 155   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 156   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 157   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 158   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 159   data.Reset();
 160
 161   // Emit a motion signal
 162   screenCoordinates.x = screenCoordinates.y = 11.0f;
 163   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 164   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) );
 165   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 166   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 167   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 168   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 169   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 170   data.Reset();
 171
 172   // Emit an up signal
 173   screenCoordinates.x = screenCoordinates.y = 12.0f;
 174   actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 175   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) );
 176   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 177   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 178   DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION );
 179   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 180   DALI_TEST_EQUALS( localCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 181   data.Reset();
 182
 183   // Emit a down signal where the actor is not present
 184   screenCoordinates.x = screenCoordinates.y = 200.0f;
 185   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 186   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 187   END_TEST;
 188 }
 189
 190 int UtcDaliTouchOutsideCameraNearFarPlanes(void)
 191 {
 192   TestApplication application;
 193
 194   Stage stage = Stage::GetCurrent();
 195   Vector2 stageSize = stage.GetSize();
 196
 197   Actor actor = Actor::New();
 198   actor.SetSize(100.0f, 100.0f);
 199   actor.SetAnchorPoint(AnchorPoint::CENTER);
 200   actor.SetParentOrigin(ParentOrigin::CENTER);
 201   stage.Add(actor);
 202
 203   // Render and notify
 204   application.SendNotification();
 205   application.Render();
 206
 207   // Get the camera's near and far planes
 208   RenderTaskList taskList = stage.GetRenderTaskList();
 209   Dali::RenderTask task = taskList.GetTask(0);
 210   CameraActor camera = task.GetCameraActor();
 211   float nearPlane = camera.GetNearClippingPlane();
 212   float farPlane = camera.GetFarClippingPlane();
 213
 214   // Calculate the current distance of the actor from the camera
 215   float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
 216   float distance = (stageSize.y * 0.5f) / tanHalfFov;
 217
 218   // Connect to actor's touched signal
 219   SignalData data;
 220   TouchEventFunctor functor( data );
 221   actor.TouchedSignal().Connect( &application, functor );
 222
 223   Vector2 screenCoordinates( stageSize.x * 0.5f, stageSize.y * 0.5f );
 224
 225   // Emit a down signal
 226   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 227   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 228   data.Reset();
 229
 230   // Emit a down signal where actor is just at the camera's near plane
 231   actor.SetZ(distance - nearPlane);
 232
 233   // Render and notify
 234   application.SendNotification();
 235   application.Render();
 236
 237   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 238   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 239   data.Reset();
 240
 241   // Emit a down signal where actor is closer than the camera's near plane
 242   actor.SetZ((distance - nearPlane) + 1.0f);
 243
 244   // Render and notify
 245   application.SendNotification();
 246   application.Render();
 247
 248   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 249   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 250   data.Reset();
 251
 252   // Emit a down signal where actor is just at the camera's far plane
 253   actor.SetZ(distance - farPlane);
 254
 255   // Render and notify
 256   application.SendNotification();
 257   application.Render();
 258
 259   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 260   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 261   data.Reset();
 262
 263   // Emit a down signal where actor is further than the camera's far plane
 264   actor.SetZ((distance - farPlane) - 1.0f);
 265
 266   // Render and notify
 267   application.SendNotification();
 268   application.Render();
 269
 270   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 271   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 272   data.Reset();
 273   END_TEST;
 274 }
 275
 276 int UtcDaliTouchEmitEmpty(void)
 277 {
 278   TestApplication application;
 279
 280   try
 281   {
 282     // Emit an empty TouchEvent
 283     Integration::TouchEvent event;
 284     application.ProcessEvent( event );
 285     tet_result( TET_FAIL );
 286   }
 287   catch ( Dali::DaliException& e )
 288   {
 289     DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION );
 290   }
 291   END_TEST;
 292 }
 293
 294 int UtcDaliTouchInterrupted(void)
 295 {
 296   TestApplication application;
 297
 298   Actor actor = Actor::New();
 299   actor.SetSize(100.0f, 100.0f);
 300   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 301   Stage::GetCurrent().Add(actor);
 302
 303   // Render and notify
 304   application.SendNotification();
 305   application.Render();
 306
 307   // Connect to actor's touched signal
 308   SignalData data;
 309   TouchEventFunctor functor( data );
 310   actor.TouchedSignal().Connect( &application, functor );
 311
 312   // Emit a down signal
 313   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 314   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 315   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 316   data.Reset();
 317
 318   // Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
 319   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
 320   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 321   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 322   data.Reset();
 323
 324   // Emit another interrupted signal, our signal handler should not be called.
 325   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 326   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 327   END_TEST;
 328 }
 329
 330 int UtcDaliTouchParentConsumer(void)
 331 {
 332   TestApplication application;
 333   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 334
 335   Actor actor = Actor::New();
 336   actor.SetSize(100.0f, 100.0f);
 337   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 338   Stage::GetCurrent().Add(actor);
 339
 340   // Render and notify
 341   application.SendNotification();
 342   application.Render();
 343
 344   // Connect to actor's touched signal
 345   SignalData data;
 346   TouchEventFunctor functor( data, false );
 347   actor.TouchedSignal().Connect( &application, functor );
 348
 349   // Connect to root actor's touched signal
 350   SignalData rootData;
 351   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 352   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 353
 354   Vector2 screenCoordinates( 10.0f, 10.0f );
 355   Vector2 actorCoordinates, rootCoordinates;
 356   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 357   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 358
 359   // Emit a down signal
 360   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 361   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 362   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 363   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 364   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 365   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 366   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 367   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 368   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 369   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 370   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 371   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 372   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 373   data.Reset();
 374   rootData.Reset();
 375
 376   // Emit a motion signal
 377   screenCoordinates.x = screenCoordinates.y = 11.0f;
 378   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 379   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 380   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, screenCoordinates ) );
 381   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 382   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 383   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 384   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 385   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 386   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 387   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 388   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 389   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 390   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 391   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 392   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 393   data.Reset();
 394   rootData.Reset();
 395
 396   // Emit an up signal
 397   screenCoordinates.x = screenCoordinates.y = 12.0f;
 398   actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 399   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 400   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Up, screenCoordinates ) );
 401   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 402   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 403   DALI_TEST_EQUALS( 1u, data.touchEvent.GetPointCount(), TEST_LOCATION );
 404   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 405   DALI_TEST_EQUALS( TouchPoint::Up, data.touchEvent.points[0].state, TEST_LOCATION );
 406   DALI_TEST_EQUALS( TouchPoint::Up, rootData.touchEvent.points[0].state, TEST_LOCATION );
 407   DALI_TEST_EQUALS( screenCoordinates, data.touchEvent.points[0].screen, TEST_LOCATION );
 408   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 409   DALI_TEST_EQUALS( actorCoordinates, data.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 410   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 411   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 412   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 413   data.Reset();
 414   rootData.Reset();
 415
 416   // Emit a down signal where the actor is not present, will hit the root actor though
 417   screenCoordinates.x = screenCoordinates.y = 200.0f;
 418   rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
 419   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, screenCoordinates ) );
 420   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 421   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 422   DALI_TEST_EQUALS( 1u, rootData.touchEvent.GetPointCount(), TEST_LOCATION );
 423   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 424   DALI_TEST_EQUALS( screenCoordinates, rootData.touchEvent.points[0].screen, TEST_LOCATION );
 425   DALI_TEST_EQUALS( rootCoordinates, rootData.touchEvent.points[0].local, 0.1f, TEST_LOCATION );
 426   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 427   END_TEST;
 428 }
 429
 430 int UtcDaliTouchInterruptedParentConsumer(void)
 431 {
 432   TestApplication application;
 433   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 434
 435   Actor actor = Actor::New();
 436   actor.SetSize(100.0f, 100.0f);
 437   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 438   Stage::GetCurrent().Add(actor);
 439
 440   // Render and notify
 441   application.SendNotification();
 442   application.Render();
 443
 444   // Connect to actor's touched signal
 445   SignalData data;
 446   TouchEventFunctor functor( data, false );
 447   actor.TouchedSignal().Connect( &application, functor );
 448
 449   // Connect to root actor's touched signal
 450   SignalData rootData;
 451   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 452   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 453
 454   // Emit a down signal
 455   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 456   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 457   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 458   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 459   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 460   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 461   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 462   data.Reset();
 463   rootData.Reset();
 464
 465   // Emit an interrupted signal
 466   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 467   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 468   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 469   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 470   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 471   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 472   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 473   data.Reset();
 474   rootData.Reset();
 475
 476   // Emit another down signal
 477   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 478   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 479   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 480   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 481   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 482   data.Reset();
 483   rootData.Reset();
 484
 485   // Remove actor from Stage
 486   Stage::GetCurrent().Remove( actor );
 487
 488   // Render and notify
 489   application.SendNotification();
 490   application.Render();
 491
 492   // Emit an interrupted signal, only root actor's signal should be called.
 493   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
 494   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 495   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 496   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 497   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 498   data.Reset();
 499   rootData.Reset();
 500
 501   // Emit another interrupted state, none of the signal's should be called.
 502   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Interrupted, Vector2( 200.0f, 200.0f ) ) );
 503   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 504   DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION );
 505   END_TEST;
 506 }
 507
 508 int UtcDaliTouchLeave(void)
 509 {
 510   TestApplication application;
 511
 512   Actor actor = Actor::New();
 513   actor.SetSize(100.0f, 100.0f);
 514   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 515   Stage::GetCurrent().Add(actor);
 516
 517   // Render and notify
 518   application.SendNotification();
 519   application.Render();
 520
 521   // Connect to actor's touched signal
 522   SignalData data;
 523   TouchEventFunctor functor( data );
 524   actor.TouchedSignal().Connect( &application, functor );
 525
 526   // Set actor to require leave events
 527   actor.SetLeaveRequired( true );
 528
 529   // Emit a down signal
 530   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 531   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 532   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 533   data.Reset();
 534
 535   // Emit a motion signal outside of actor, should be signalled with a Leave
 536   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 537   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 538   DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION );
 539   data.Reset();
 540
 541   // Another motion outside of actor, no signalling
 542   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) );
 543   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 544   data.Reset();
 545
 546   // Another motion event inside actor, signalled with motion
 547   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) );
 548   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 549   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 550   data.Reset();
 551
 552   // We do not want to listen to leave events anymore
 553   actor.SetLeaveRequired( false );
 554
 555   // Another motion event outside of actor, no signalling
 556   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 557   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 558   data.Reset();
 559   END_TEST;
 560 }
 561
 562 int UtcDaliTouchLeaveParentConsumer(void)
 563 {
 564   TestApplication application;
 565   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 566
 567   Actor actor = Actor::New();
 568   actor.SetSize(100.0f, 100.0f);
 569   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 570   Stage::GetCurrent().Add(actor);
 571
 572   // Render and notify
 573   application.SendNotification();
 574   application.Render();
 575
 576   // Connect to actor's touched signal
 577   SignalData data;
 578   TouchEventFunctor functor( data, false );
 579   actor.TouchedSignal().Connect( &application, functor );
 580
 581   // Connect to root actor's touched signal
 582   SignalData rootData;
 583   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 584   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 585
 586   // Set actor to require leave events
 587   actor.SetLeaveRequired( true );
 588   rootActor.SetLeaveRequired( true );
 589
 590   // Emit a down signal
 591   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 592   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 593   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 594   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 595   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 596   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 597   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 598   data.Reset();
 599   rootData.Reset();
 600
 601   // Emit a motion signal outside of actor, should be signalled with a Leave
 602   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 603   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 604   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 605   DALI_TEST_EQUALS( TouchPoint::Leave, data.touchEvent.points[0].state, TEST_LOCATION );
 606   DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION );
 607   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 608   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 609   data.Reset();
 610   rootData.Reset();
 611
 612   // Another motion outside of actor, only rootActor signalled
 613   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 201.0f, 201.0f )) );
 614   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 615   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 616   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 617   DALI_TEST_CHECK( rootActor == rootData.touchEvent.points[0].hitActor );
 618   data.Reset();
 619   rootData.Reset();
 620
 621   // Another motion event inside actor, signalled with motion
 622   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 10.0f, 10.0f )) );
 623   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 624   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 625   DALI_TEST_EQUALS( TouchPoint::Motion, data.touchEvent.points[0].state, TEST_LOCATION );
 626   DALI_TEST_EQUALS( TouchPoint::Motion, rootData.touchEvent.points[0].state, TEST_LOCATION );
 627   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 628   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 629   data.Reset();
 630   rootData.Reset();
 631
 632   // We do not want to listen to leave events of actor anymore
 633   actor.SetLeaveRequired( false );
 634
 635   // Another motion event outside of root actor, only root signalled
 636   Vector2 stageSize( Stage::GetCurrent().GetSize() );
 637   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( stageSize.width + 10.0f, stageSize.height + 10.0f )) );
 638   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 639   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 640   DALI_TEST_EQUALS( TouchPoint::Leave, rootData.touchEvent.points[0].state, TEST_LOCATION );
 641   END_TEST;
 642 }
 643
 644 int UtcDaliTouchActorBecomesInsensitive(void)
 645 {
 646   TestApplication application;
 647
 648   Actor actor = Actor::New();
 649   actor.SetSize(100.0f, 100.0f);
 650   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 651   Stage::GetCurrent().Add(actor);
 652
 653   // Render and notify
 654   application.SendNotification();
 655   application.Render();
 656
 657   // Connect to actor's touched signal
 658   SignalData data;
 659   TouchEventFunctor functor( data );
 660   actor.TouchedSignal().Connect( &application, functor );
 661
 662   // Emit a down signal
 663   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 664   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 665   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 666   data.Reset();
 667
 668   // Change actor to insensitive
 669   actor.SetSensitive( false );
 670
 671   // Emit a motion signal, signalled with an interrupted
 672   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2 ( 200.0f, 200.0f )) );
 673   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 674   DALI_TEST_EQUALS( TouchPoint::Interrupted, data.touchEvent.points[0].state, TEST_LOCATION );
 675   data.Reset();
 676   END_TEST;
 677 }
 678
 679 int UtcDaliTouchActorBecomesInsensitiveParentConsumer(void)
 680 {
 681   TestApplication application;
 682   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 683
 684   Actor actor = Actor::New();
 685   actor.SetSize(100.0f, 100.0f);
 686   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 687   Stage::GetCurrent().Add(actor);
 688
 689   // Render and notify
 690   application.SendNotification();
 691   application.Render();
 692
 693   // Connect to actor's touched signal
 694   SignalData data;
 695   TouchEventFunctor functor( data, false );
 696   actor.TouchedSignal().Connect( &application, functor );
 697
 698   // Connect to root actor's touched signal
 699   SignalData rootData;
 700   TouchEventFunctor rootFunctor( rootData ); // Consumes signal
 701   rootActor.TouchedSignal().Connect( &application, rootFunctor );
 702
 703   // Emit a down signal
 704   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 705   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 706   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 707   DALI_TEST_EQUALS( TouchPoint::Down, data.touchEvent.points[0].state, TEST_LOCATION );
 708   DALI_TEST_EQUALS( TouchPoint::Down, rootData.touchEvent.points[0].state, TEST_LOCATION );
 709   DALI_TEST_CHECK( actor == data.touchEvent.points[0].hitActor );
 710   DALI_TEST_CHECK( actor == rootData.touchEvent.points[0].hitActor );
 711   data.Reset();
 712   rootData.Reset();
 713
 714   // Remove actor from Stage
 715   Stage::GetCurrent().Remove( actor );
 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( false, data.functorCalled, TEST_LOCATION );
 727   DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
 728   DALI_TEST_EQUALS( TouchPoint::Interrupted, rootData.touchEvent.points[0].state, TEST_LOCATION );
 729   END_TEST;
 730 }
 731
 732 int UtcDaliTouchMultipleLayers(void)
 733 {
 734   TestApplication application;
 735   Actor rootActor( Stage::GetCurrent().GetRootLayer() );
 736
 737   // Connect to actor's touched signal
 738   SignalData data;
 739   TouchEventFunctor functor( data );
 740
 741   Layer layer1 ( Layer::New() );
 742   layer1.SetSize(100.0f, 100.0f);
 743   layer1.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 744   Stage::GetCurrent().Add( layer1 );
 745
 746   Actor actor1 ( Actor::New() );
 747   actor1.SetSize( 100.0f, 100.0f );
 748   actor1.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 749   actor1.SetZ( 1.0f ); // Should hit actor1 in this layer
 750   layer1.Add( actor1 );
 751
 752   // Render and notify
 753   application.SendNotification();
 754   application.Render();
 755
 756   // Connect to layer1 and actor1
 757   layer1.TouchedSignal().Connect( &application, functor );
 758   actor1.TouchedSignal().Connect( &application, functor );
 759
 760   // Hit in hittable area, actor1 should be hit
 761   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 762   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 763   DALI_TEST_CHECK( data.touchedActor == actor1 );
 764   data.Reset();
 765
 766   // Make layer1 insensitive, nothing should be hit
 767   layer1.SetSensitive( false );
 768   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 769   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 770   data.Reset();
 771
 772   // Make layer1 sensitive again, again actor1 will be hit
 773   layer1.SetSensitive( true );
 774   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 775   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 776   DALI_TEST_CHECK( data.touchedActor == actor1 );
 777   data.Reset();
 778
 779   // Make rootActor insensitive, nothing should be hit
 780   rootActor.SetSensitive( false );
 781   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 782   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 783   data.Reset();
 784
 785   // Make rootActor sensitive
 786   rootActor.SetSensitive( true );
 787
 788   // Add another layer
 789   Layer layer2 ( Layer::New() );
 790   layer2.SetSize(100.0f, 100.0f );
 791   layer2.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 792   layer2.SetZ( 10.0f ); // Should hit layer2 in this layer rather than actor2
 793   Stage::GetCurrent().Add( layer2 );
 794
 795   Actor actor2 ( Actor::New() );
 796   actor2.SetSize(100.0f, 100.0f);
 797   actor2.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 798   layer2.Add( actor2 );
 799
 800   // Render and notify
 801   application.SendNotification();
 802   application.Render();
 803
 804   // Connect to layer2 and actor2
 805   layer2.TouchedSignal().Connect( &application, functor );
 806   actor2.TouchedSignal().Connect( &application, functor );
 807
 808   // Emit an event, should hit layer2
 809   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 810   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 811   //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
 812   data.Reset();
 813
 814   // Make layer2 insensitive, should hit actor1
 815   layer2.SetSensitive( false );
 816   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 817   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 818   DALI_TEST_CHECK( data.touchedActor == actor1 );
 819   data.Reset();
 820
 821   // Make layer2 sensitive again, should hit layer2
 822   layer2.SetSensitive( true );
 823   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 824   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 825   //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
 826   data.Reset();
 827
 828   // Make layer2 invisible, render and notify
 829   layer2.SetVisible( false );
 830   application.SendNotification();
 831   application.Render();
 832
 833   // Should hit actor1
 834   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 835   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 836   DALI_TEST_CHECK( data.touchedActor == actor1 );
 837   data.Reset();
 838
 839   // Make rootActor invisible, render and notify
 840   rootActor.SetVisible( false );
 841   application.SendNotification();
 842   application.Render();
 843
 844   // Should not hit anything
 845   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 846   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 847   data.Reset();
 848   END_TEST;
 849 }
 850
 851 int UtcDaliTouchMultipleRenderTasks(void)
 852 {
 853   TestApplication application;
 854   Stage stage ( Stage::GetCurrent() );
 855   Vector2 stageSize ( stage.GetSize() );
 856
 857   Actor actor = Actor::New();
 858   actor.SetSize(100.0f, 100.0f);
 859   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 860   stage.Add(actor);
 861
 862   // Create render task
 863   Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
 864   RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() );
 865   renderTask.SetViewport( viewport );
 866   renderTask.SetInputEnabled( true );
 867
 868   // Render and notify
 869   application.SendNotification();
 870   application.Render();
 871
 872   // Connect to actor's touched signal
 873   SignalData data;
 874   TouchEventFunctor functor( data );
 875   actor.TouchedSignal().Connect( &application, functor );
 876
 877   // Emit a down signal
 878   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 879   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 880   data.Reset();
 881
 882   // Ensure renderTask actor can be hit too.
 883   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 884   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 885   data.Reset();
 886
 887   // Disable input on renderTask, should not be hittable
 888   renderTask.SetInputEnabled( false );
 889   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 890   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 891   data.Reset();
 892   END_TEST;
 893 }
 894
 895 int UtcDaliTouchMultipleRenderTasksWithChildLayer(void)
 896 {
 897   TestApplication application;
 898   Stage stage ( Stage::GetCurrent() );
 899   Vector2 stageSize ( stage.GetSize() );
 900
 901   Actor actor = Actor::New();
 902   actor.SetSize(100.0f, 100.0f);
 903   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 904   stage.Add(actor);
 905
 906   Layer layer = Layer::New();
 907   layer.SetSize(100.0f, 100.0f);
 908   layer.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 909   actor.Add(layer);
 910
 911   // Create render task
 912   Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
 913   RenderTask renderTask ( Stage::GetCurrent().GetRenderTaskList().CreateTask() );
 914   renderTask.SetViewport( viewport );
 915   renderTask.SetInputEnabled( true );
 916   renderTask.SetSourceActor( actor );
 917
 918   // Render and notify
 919   application.SendNotification();
 920   application.Render();
 921
 922   // Connect to layer's touched signal
 923   SignalData data;
 924   TouchEventFunctor functor( data );
 925   actor.TouchedSignal().Connect( &application, functor );
 926   layer.TouchedSignal().Connect( &application, functor );
 927
 928   // Emit a down signal
 929   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 930   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 931   data.Reset();
 932
 933   // Ensure renderTask actor can be hit too.
 934   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 935   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 936   data.Reset();
 937
 938   // Disable input on renderTask, should not be hittable
 939   renderTask.SetInputEnabled( false );
 940   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
 941   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 942   data.Reset();
 943   END_TEST;
 944 }
 945
 946 int UtcDaliTouchOffscreenRenderTasks(void)
 947 {
 948   TestApplication application;
 949   Stage stage ( Stage::GetCurrent() );
 950   Vector2 stageSize ( stage.GetSize() );
 951
 952   // FrameBufferImage for offscreen RenderTask
 953   FrameBufferImage frameBufferImage( FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 ) );
 954
 955   // Create an image actor to display the FrameBufferImage
 956   ImageActor imageActor ( ImageActor::New( frameBufferImage ) );
 957   imageActor.SetParentOrigin(ParentOrigin::CENTER);
 958   imageActor.SetSize( stageSize.x, stageSize.y );
 959   imageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
 960   stage.Add( imageActor );
 961
 962   Actor actor = Actor::New();
 963   actor.SetSize(100.0f, 100.0f);
 964   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
 965   stage.Add( actor );
 966   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects
 967
 968   stage.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
 969
 970   // Create a RenderTask
 971   RenderTask renderTask = stage.GetRenderTaskList().CreateTask();
 972   renderTask.SetSourceActor( actor );
 973   renderTask.SetTargetFrameBuffer( frameBufferImage );
 974   renderTask.SetInputEnabled( true );
 975
 976   // Create another RenderTask
 977   RenderTask renderTask2( stage.GetRenderTaskList().CreateTask() );
 978   renderTask2.SetInputEnabled( true );
 979
 980   // Render and notify
 981   application.SendNotification();
 982   application.Render();
 983
 984   // Connect to actor's touched signal
 985   SignalData data;
 986   TouchEventFunctor functor( data );
 987   actor.TouchedSignal().Connect( &application, functor );
 988
 989   // Emit a down signal
 990   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
 991   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 992   data.Reset();
 993   END_TEST;
 994 }
 995
 996 int UtcDaliTouchMultipleRenderableActors(void)
 997 {
 998   TestApplication application;
 999   Stage stage ( Stage::GetCurrent() );
1000   Vector2 stageSize ( stage.GetSize() );
1001
1002   Actor parent = ImageActor::New();
1003   parent.SetSize(100.0f, 100.0f);
1004   parent.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1005   stage.Add(parent);
1006
1007   Actor actor = ImageActor::New();
1008   actor.SetSize(100.0f, 100.0f);
1009   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1010   parent.Add(actor);
1011
1012   // Render and notify
1013   application.SendNotification();
1014   application.Render();
1015
1016   // Connect to layer's touched signal
1017   SignalData data;
1018   TouchEventFunctor functor( data );
1019   parent.TouchedSignal().Connect( &application, functor );
1020   actor.TouchedSignal().Connect( &application, functor );
1021
1022   // Emit a down signal
1023   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1024   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1025   DALI_TEST_CHECK( actor == data.touchedActor );
1026   END_TEST;
1027 }
1028
1029 int UtcDaliTouchActorRemovedInSignal(void)
1030 {
1031   TestApplication application;
1032
1033   Actor actor = Actor::New();
1034   actor.SetSize(100.0f, 100.0f);
1035   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1036   Stage::GetCurrent().Add(actor);
1037
1038   // Render and notify
1039   application.SendNotification();
1040   application.Render();
1041
1042   // Connect to actor's touched signal
1043   SignalData data;
1044   RemoveActorFunctor functor( data );
1045   actor.TouchedSignal().Connect( &application, functor );
1046
1047   // Register for leave events
1048   actor.SetLeaveRequired( true );
1049
1050   // Emit a down signal
1051   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1052   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1053   data.Reset();
1054
1055   // Re-add, render and notify
1056   Stage::GetCurrent().Add(actor);
1057   application.SendNotification();
1058   application.Render();
1059
1060   // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1061   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1062   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1063   data.Reset();
1064
1065   // Emit a down signal
1066   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1067   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1068   data.Reset();
1069
1070   // Render and notify
1071   application.SendNotification();
1072   application.Render();
1073
1074   // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1075   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1076   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1077   data.Reset();
1078
1079   // Re-add actor back to stage, render and notify
1080   Stage::GetCurrent().Add(actor);
1081   application.SendNotification();
1082   application.Render();
1083
1084   // Emit another down event
1085   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1086   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1087   data.Reset();
1088
1089   // Completely delete the actor
1090   actor = NULL;
1091
1092   // Emit event, should not crash and should not receive an event.
1093   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 210.0f, 210.0f ) ) );
1094   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1095   END_TEST;
1096 }
1097
1098 int UtcDaliTouchActorSignalNotConsumed(void)
1099 {
1100   TestApplication application;
1101
1102   Actor actor = Actor::New();
1103   actor.SetSize(100.0f, 100.0f);
1104   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1105   Stage::GetCurrent().Add(actor);
1106
1107   // Render and notify
1108   application.SendNotification();
1109   application.Render();
1110
1111   // Connect to actor's touched signal
1112   SignalData data;
1113   TouchEventFunctor functor( data, false );
1114   actor.TouchedSignal().Connect( &application, functor );
1115
1116   // Emit a down signal
1117   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1118   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1119   END_TEST;
1120 }
1121
1122 int UtcDaliTouchActorUnStaged(void)
1123 {
1124   TestApplication application;
1125
1126   Actor actor = Actor::New();
1127   actor.SetSize(100.0f, 100.0f);
1128   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1129   Stage::GetCurrent().Add(actor);
1130
1131   // Render and notify
1132   application.SendNotification();
1133   application.Render();
1134
1135   // Connect to actor's touched signal
1136   SignalData data;
1137   TouchEventFunctor functor( data );
1138   actor.TouchedSignal().Connect( &application, functor );
1139
1140   // Emit a down signal
1141   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1142   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1143   data.Reset();
1144
1145   // Remove actor from stage
1146   Stage::GetCurrent().Remove( actor );
1147
1148   // Render and notify
1149   application.SendNotification();
1150   application.Render();
1151
1152   // Emit a move at the same point, we should not be signalled.
1153   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Motion, Vector2( 10.0f, 10.0f ) ) );
1154   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1155   data.Reset();
1156   END_TEST;
1157 }
1158
1159 int UtcDaliTouchSystemOverlayActor(void)
1160 {
1161   TestApplication application;
1162   Dali::Integration::Core& core( application.GetCore() );
1163   Dali::Integration::SystemOverlay& systemOverlay( core.GetSystemOverlay() );
1164   systemOverlay.GetOverlayRenderTasks().CreateTask();
1165
1166   // Create an actor and add it to the system overlay.
1167   Actor systemActor = Actor::New();
1168   systemActor.SetSize(100.0f, 100.0f);
1169   systemActor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1170   systemOverlay.Add( systemActor );
1171
1172   // Create an actor and add it to the stage as per normal, same position and size as systemActor
1173   Actor actor = Actor::New();
1174   actor.SetSize(100.0f, 100.0f);
1175   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1176   Stage::GetCurrent().Add(actor);
1177
1178   // Connect to the touch signals.
1179   SignalData data;
1180   TouchEventFunctor functor( data );
1181   systemActor.TouchedSignal().Connect( &application, functor );
1182   actor.TouchedSignal().Connect( &application, functor );
1183
1184   // Render and notify
1185   application.SendNotification();
1186   application.Render();
1187
1188   // Emit a down signal, the system overlay is drawn last so is at the top, should hit the systemActor.
1189   application.ProcessEvent( GenerateSingleTouch( TouchPoint::Down, Vector2( 10.0f, 10.0f ) ) );
1190   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1191   DALI_TEST_CHECK( systemActor == data.touchedActor );
1192   END_TEST;
1193 }