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

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