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

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