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

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