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

   1 /*
   2  * Copyright (c) 2018 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/devel-api/common/map-wrapper.h>
  23 #include <dali/devel-api/common/stage-devel.h>
  24 #include <dali/devel-api/update/frame-callback-interface.h>
  25 #include <dali/devel-api/update/update-proxy.h>
  26 #include <dali-test-suite-utils.h>
  27
  28 using namespace Dali;
  29
  30 void utc_dali_frame_callback_interface_startup(void)
  31 {
  32   test_return_value = TET_UNDEF;
  33 }
  34
  35 void utc_dali_frame_callback_interface_cleanup(void)
  36 {
  37   test_return_value = TET_PASS;
  38 }
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41 namespace
  42 {
  43
  44 class FrameCallbackBasic : public FrameCallbackInterface
  45 {
  46 public:
  47
  48   FrameCallbackBasic() = default;
  49
  50   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds )
  51   {
  52     mCalled = true;
  53   }
  54
  55   virtual void Reset()
  56   {
  57     mCalled = false;
  58   }
  59
  60   bool mCalled{ false };
  61 };
  62
  63 } // anon namespace
  64
  65 class FrameCallbackOneActor : public FrameCallbackBasic
  66 {
  67 public:
  68
  69   FrameCallbackOneActor( unsigned int actorId )
  70   : mActorId( actorId )
  71   {
  72   }
  73
  74   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
  75   {
  76     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
  77     updateProxy.GetSize( mActorId, mSizeGetSizeCall );
  78     updateProxy.GetPosition( mActorId, mPositionGetPositionCall );
  79     updateProxy.GetPositionAndSize( mActorId, mPositionGetPositionAndSizeCall, mSizeGetPositionAndSizeCall );
  80     updateProxy.GetColor( mActorId, mColor );
  81     updateProxy.GetScale( mActorId, mScale );
  82   }
  83
  84   const unsigned int mActorId;
  85
  86   Vector3 mSizeGetSizeCall;
  87   Vector3 mPositionGetPositionCall;
  88   Vector3 mPositionGetPositionAndSizeCall;
  89   Vector3 mSizeGetPositionAndSizeCall;
  90   Vector4 mColor;
  91   Vector3 mScale;
  92 };
  93
  94 class FrameCallbackSetter : public FrameCallbackBasic
  95 {
  96 public:
  97
  98   FrameCallbackSetter(
  99       unsigned int actorId,
 100       const Vector3& sizeToSet,
 101       const Vector3& positionToSet,
 102       const Vector4& colorToSet,
 103       const Vector3& scaleToSet )
 104   : mActorId( actorId ),
 105     mSizeToSet( sizeToSet ),
 106     mPositionToSet( positionToSet ),
 107     mColorToSet( colorToSet ),
 108     mScaleToSet( scaleToSet )
 109   {
 110   }
 111
 112   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
 113   {
 114     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
 115     updateProxy.SetSize( mActorId, mSizeToSet );
 116     updateProxy.SetPosition( mActorId, mPositionToSet );
 117     updateProxy.SetColor( mActorId, mColorToSet );
 118     updateProxy.SetScale( mActorId, mScaleToSet );
 119     updateProxy.GetSize( mActorId, mSizeAfterSetting );
 120     updateProxy.GetPosition( mActorId, mPositionAfterSetting );
 121     updateProxy.GetColor( mActorId, mColorAfterSetting );
 122     updateProxy.GetScale( mActorId, mScaleAfterSetting );
 123   }
 124
 125   const unsigned int mActorId;
 126   const Vector3& mSizeToSet;
 127   const Vector3& mPositionToSet;
 128   const Vector4& mColorToSet;
 129   const Vector3& mScaleToSet;
 130
 131   Vector3 mSizeAfterSetting;
 132   Vector3 mPositionAfterSetting;
 133   Vector4 mColorAfterSetting;
 134   Vector3 mScaleAfterSetting;
 135 };
 136
 137 class FrameCallbackBaker : public FrameCallbackBasic
 138 {
 139 public:
 140
 141   FrameCallbackBaker(
 142       unsigned int actorId,
 143       const Vector3& sizeToSet,
 144       const Vector3& positionToSet,
 145       const Vector4& colorToSet,
 146       const Vector3& scaleToSet )
 147   : mActorId( actorId ),
 148     mSizeToSet( sizeToSet ),
 149     mPositionToSet( positionToSet ),
 150     mColorToSet( colorToSet ),
 151     mScaleToSet( scaleToSet )
 152   {
 153   }
 154
 155   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
 156   {
 157     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
 158     updateProxy.BakeSize( mActorId, mSizeToSet );
 159     updateProxy.BakePosition( mActorId, mPositionToSet );
 160     updateProxy.BakeColor( mActorId, mColorToSet );
 161     updateProxy.BakeScale( mActorId, mScaleToSet );
 162     updateProxy.GetSize( mActorId, mSizeAfterSetting );
 163     updateProxy.GetPosition( mActorId, mPositionAfterSetting );
 164     updateProxy.GetColor( mActorId, mColorAfterSetting );
 165     updateProxy.GetScale( mActorId, mScaleAfterSetting );
 166   }
 167
 168   const unsigned int mActorId;
 169   const Vector3& mSizeToSet;
 170   const Vector3& mPositionToSet;
 171   const Vector4& mColorToSet;
 172   const Vector3& mScaleToSet;
 173
 174   Vector3 mSizeAfterSetting;
 175   Vector3 mPositionAfterSetting;
 176   Vector4 mColorAfterSetting;
 177   Vector3 mScaleAfterSetting;
 178 };
 179
 180 class FrameCallbackMultipleActors : public FrameCallbackBasic
 181 {
 182 public:
 183
 184   FrameCallbackMultipleActors()
 185   {
 186   }
 187
 188   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
 189   {
 190     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
 191     for( auto&& i : mActorIds )
 192     {
 193       Vector3 position;
 194       Vector3 size;
 195       updateProxy.GetPositionAndSize( i, position, size );
 196       mPositions[ i ] = position;
 197       mSizes[ i ] = size;
 198     }
 199   }
 200
 201   Vector< unsigned int > mActorIds;
 202
 203   std::map< unsigned int, Vector3 > mPositions;
 204   std::map< unsigned int, Vector3 > mSizes;
 205 };
 206
 207 class FrameCallbackActorIdCheck : public FrameCallbackBasic
 208 {
 209 public:
 210
 211   FrameCallbackActorIdCheck( unsigned int actorId )
 212   : mActorId( actorId )
 213   {
 214   }
 215
 216   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
 217   {
 218     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
 219     Vector3 vec3;
 220     Vector4 vec4;
 221
 222     mGetSizeCallSuccess            = updateProxy.GetSize( mActorId, vec3 );
 223     mGetPositionCallSuccess        = updateProxy.GetPosition( mActorId, vec3 );
 224     mGetColorCallSuccess           = updateProxy.GetColor( mActorId, vec4 );
 225     mGetScaleCallSuccess           = updateProxy.GetScale( mActorId, vec3 );
 226     mGetPositionAndSizeCallSuccess = updateProxy.GetPositionAndSize( mActorId, vec3, vec3 );
 227     mSetSizeCallSuccess            = updateProxy.SetSize( mActorId, vec3 );
 228     mSetPositionCallSuccess        = updateProxy.SetPosition( mActorId, vec3 );
 229     mSetColorCallSuccess           = updateProxy.SetColor( mActorId, vec4 );
 230     mSetScaleCallSuccess           = updateProxy.SetScale( mActorId, vec3 );
 231     mBakeSizeCallSuccess           = updateProxy.BakeSize( mActorId, vec3 );
 232     mBakePositionCallSuccess       = updateProxy.BakePosition( mActorId, vec3 );
 233     mBakeColorCallSuccess          = updateProxy.BakeColor( mActorId, vec4 );
 234     mBakeScaleCallSuccess          = updateProxy.BakeScale( mActorId, vec3 );
 235   }
 236
 237   virtual void Reset() override
 238   {
 239     // Up-call
 240     FrameCallbackBasic::Reset();
 241
 242     mGetSizeCallSuccess = false;
 243     mGetPositionCallSuccess = false;
 244     mGetColorCallSuccess = false;
 245     mGetScaleCallSuccess = false;
 246     mGetPositionAndSizeCallSuccess = false;
 247     mSetSizeCallSuccess = false;
 248     mSetPositionCallSuccess = false;
 249     mSetColorCallSuccess = false;
 250     mSetScaleCallSuccess = false;
 251     mBakeSizeCallSuccess = false;
 252     mBakePositionCallSuccess = false;
 253     mBakeColorCallSuccess = false;
 254     mBakeScaleCallSuccess = false;
 255   }
 256
 257   const uint32_t mActorId;
 258   bool mGetSizeCallSuccess{ false };
 259   bool mGetPositionCallSuccess{ false };
 260   bool mGetColorCallSuccess{ false };
 261   bool mGetScaleCallSuccess{ false };
 262   bool mGetPositionAndSizeCallSuccess{ false };
 263   bool mSetSizeCallSuccess{ false };
 264   bool mSetPositionCallSuccess{ false };
 265   bool mSetColorCallSuccess{ false };
 266   bool mSetScaleCallSuccess{ false };
 267   bool mBakeSizeCallSuccess{ false };
 268   bool mBakePositionCallSuccess{ false };
 269   bool mBakeColorCallSuccess{ false };
 270   bool mBakeScaleCallSuccess{ false };
 271 };
 272
 273 ///////////////////////////////////////////////////////////////////////////////
 274
 275 int UtcDaliFrameCallbackCheckInstallationAndRemoval(void)
 276 {
 277   // Basic test to check that the frame-callback can be installed and removed correctly
 278
 279   TestApplication application;
 280
 281   FrameCallbackBasic frameCallback;
 282
 283   Stage stage = Stage::GetCurrent();
 284   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 285
 286   application.SendNotification();
 287   application.Render();
 288
 289   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 290
 291   frameCallback.mCalled = false;
 292
 293   DevelStage::RemoveFrameCallback( stage, frameCallback );
 294
 295   application.SendNotification();
 296   application.Render();
 297
 298   DALI_TEST_EQUALS( frameCallback.mCalled, false, TEST_LOCATION );
 299
 300   END_TEST;
 301 }
 302
 303 int UtcDaliFrameCallbackGetters(void)
 304 {
 305   // Test to see that the Getters all return the expected values
 306
 307   TestApplication application;
 308   Vector2 actorSize( 200, 300 );
 309   Vector4 color( 0.5f, 0.6f, 0.7f, 0.8f );
 310   Vector3 position( 10.0f, 20.0f, 30.0f );
 311   Vector3 scale( 2.0f, 4.0f, 6.0f );
 312
 313   Actor actor = Actor::New();
 314   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 315   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 316   actor.SetSize( actorSize );
 317   actor.SetColor( color );
 318   actor.SetPosition( position );
 319   actor.SetScale( scale );
 320
 321   Stage stage = Stage::GetCurrent();
 322   stage.Add( actor );
 323
 324   FrameCallbackOneActor frameCallback( actor.GetId() );
 325   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 326
 327   application.SendNotification();
 328   application.Render();
 329
 330   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 331   DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
 332   DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, position, TEST_LOCATION );
 333   DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION );
 334   DALI_TEST_EQUALS( frameCallback.mSizeGetPositionAndSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
 335   DALI_TEST_EQUALS( frameCallback.mColor, color, TEST_LOCATION );
 336   DALI_TEST_EQUALS( frameCallback.mScale, scale, TEST_LOCATION );
 337
 338   END_TEST;
 339 }
 340
 341 int UtcDaliFrameCallbackSetters(void)
 342 {
 343   // Test to see that the setters set the values appropriately
 344
 345   TestApplication application;
 346   Vector2 actorSize( 200, 300 );
 347
 348   Actor actor = Actor::New();
 349   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 350   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 351   actor.SetSize( actorSize );
 352
 353   Stage stage = Stage::GetCurrent();
 354   stage.Add( actor );
 355
 356   Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
 357   Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
 358   Vector4 colorToSet( Color::MAGENTA );
 359   Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
 360
 361   FrameCallbackSetter frameCallback( actor.GetId(), sizeToSet, positionToSet, colorToSet, scaleToSet );
 362   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 363
 364   application.SendNotification();
 365   application.Render();
 366
 367   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 368   DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
 369   DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
 370   DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
 371   DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
 372
 373   // Ensure the actual actor values haven't changed as we didn't bake the values after removing the callback
 374   DevelStage::RemoveFrameCallback( stage, frameCallback );
 375
 376   application.SendNotification();
 377   application.Render();
 378
 379   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), Vector3::ZERO, TEST_LOCATION );
 380   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), Vector3( actorSize ), TEST_LOCATION );
 381   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), Color::WHITE, TEST_LOCATION );
 382   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
 383
 384   END_TEST;
 385 }
 386
 387 int UtcDaliFrameCallbackBake(void)
 388 {
 389   // Test to see that the bake methods bake the values
 390
 391   TestApplication application;
 392   Vector2 actorSize( 200, 300 );
 393
 394   Actor actor = Actor::New();
 395   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 396   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 397   actor.SetSize( actorSize );
 398
 399   Stage stage = Stage::GetCurrent();
 400   stage.Add( actor );
 401
 402   Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
 403   Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
 404   Vector4 colorToSet( Color::MAGENTA );
 405   Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
 406
 407   FrameCallbackBaker frameCallback( actor.GetId(), sizeToSet, positionToSet, colorToSet, scaleToSet );
 408   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 409
 410   application.SendNotification();
 411   application.Render();
 412
 413   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 414   DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
 415   DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
 416   DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
 417   DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
 418
 419   // Ensure the new values are saved after removing the callback
 420   DevelStage::RemoveFrameCallback( stage, frameCallback );
 421
 422   application.SendNotification();
 423   application.Render();
 424
 425   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), positionToSet, TEST_LOCATION );
 426   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), sizeToSet, TEST_LOCATION );
 427   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), colorToSet, TEST_LOCATION );
 428   DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), scaleToSet, TEST_LOCATION );
 429
 430   END_TEST;
 431 }
 432
 433
 434 int UtcDaliFrameCallbackMultipleActors(void)
 435 {
 436   /**
 437    * Test to check that the frame callback behaves appropriately with multiple actors
 438    *
 439    * Tree:
 440    *              root-layer
 441    *              /        \
 442    *             /          \
 443    *            /            \
 444    *           /              \
 445    *        actorA           actorE
 446    *         / \              / \
 447    *        /   \            /   \
 448    *    actorB  actorD   actorF actorG
 449    *      /                        \
 450    *   actorC                     actorH
 451    *
 452    *  Screen positions (with minor alterations due to local position):
 453    *  -----------------------
 454    *  |actorA|actorD        |
 455    *  |      actorB         |
 456    *  |      actorC         |
 457    *  |                     |
 458    *  |                     |
 459    *  |                     |
 460    *  |                     |
 461    *  |                     |
 462    *  |actorF       actorH  |
 463    *  |actorE|actorG        |
 464    *  -----------------------
 465    */
 466
 467   TestApplication application;
 468   Stage stage = Stage::GetCurrent();
 469
 470   std::map< char, Vector3 > sizes;
 471   sizes['A'] = Vector3(  50.0f,  50.0f, 0.0f );
 472   sizes['B'] = Vector3( 100.0f, 100.0f, 0.0f );
 473   sizes['C'] = Vector3( 150.0f, 150.0f, 0.0f );
 474   sizes['D'] = Vector3( 200.0f, 200.0f, 0.0f );
 475   sizes['E'] = Vector3( 250.0f, 250.0f, 0.0f );
 476   sizes['F'] = Vector3( 300.0f, 300.0f, 0.0f );
 477   sizes['G'] = Vector3( 350.0f, 350.0f, 0.0f );
 478   sizes['H'] = Vector3( 400.0f, 350.0f, 0.0f );
 479
 480   std::map< char, Vector3 > positions;
 481   positions['A'] = Vector3(  0.0f,  1.0f,  2.0f );
 482   positions['B'] = Vector3(  2.0f,  3.0f,  4.0f );
 483   positions['C'] = Vector3(  5.0f,  6.0f,  7.0f );
 484   positions['D'] = Vector3(  8.0f,  9.0f, 10.0f );
 485   positions['E'] = Vector3( 11.0f, 12.0f, 13.0f );
 486   positions['F'] = Vector3( 14.0f, 15.0f, 16.0f );
 487   positions['G'] = Vector3( 17.0f, 18.0f, 19.0f );
 488   positions['H'] = Vector3( 20.0f, 21.0f, 22.0f );
 489
 490   Actor actorA = Actor::New();
 491   actorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
 492   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 493   actorA.SetSize( sizes['A'] );
 494   actorA.SetPosition( positions['A'] );
 495   stage.Add( actorA );
 496
 497   Actor actorB = Actor::New();
 498   actorB.SetParentOrigin( ParentOrigin::BOTTOM_RIGHT );
 499   actorB.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 500   actorB.SetSize( sizes['B'] );
 501   actorB.SetPosition( positions['B'] );
 502   actorA.Add( actorB );
 503
 504   Actor actorC = Actor::New();
 505   actorC.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
 506   actorC.SetAnchorPoint( AnchorPoint::TOP_CENTER );
 507   actorC.SetSize( sizes['C'] );
 508   actorC.SetPosition( positions['C'] );
 509   actorB.Add( actorC );
 510
 511   Actor actorD = Actor::New();
 512   actorD.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
 513   actorD.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 514   actorD.SetSize( sizes['D'] );
 515   actorD.SetPosition( positions['D'] );
 516   actorA.Add( actorD );
 517
 518   Actor actorE = Actor::New();
 519   actorE.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
 520   actorE.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
 521   actorE.SetSize( sizes['E'] );
 522   actorE.SetPosition( positions['E'] );
 523   stage.Add( actorE );
 524
 525   Actor actorF = Actor::New();
 526   actorF.SetParentOrigin( ParentOrigin::TOP_CENTER );
 527   actorF.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
 528   actorF.SetSize( sizes['F'] );
 529   actorF.SetPosition( positions['F'] );
 530   actorE.Add( actorF );
 531
 532   Actor actorG = Actor::New();
 533   actorG.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
 534   actorG.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 535   actorG.SetSize( sizes['G'] );
 536   actorG.SetPosition( positions['G'] );
 537   actorE.Add( actorG );
 538
 539   Actor actorH = Actor::New();
 540   actorH.SetParentOrigin( ParentOrigin::TOP_RIGHT );
 541   actorH.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
 542   actorH.SetSize( sizes['H'] );
 543   actorH.SetPosition( positions['H'] );
 544   actorG.Add( actorH );
 545
 546   std::map< char, unsigned int > actorIds;
 547   actorIds['A'] = actorA.GetId();
 548   actorIds['B'] = actorB.GetId();
 549   actorIds['C'] = actorC.GetId();
 550   actorIds['D'] = actorD.GetId();
 551   actorIds['E'] = actorE.GetId();
 552   actorIds['F'] = actorF.GetId();
 553   actorIds['G'] = actorG.GetId();
 554   actorIds['H'] = actorH.GetId();
 555
 556   FrameCallbackMultipleActors frameCallback;
 557   for( auto&& i : actorIds )
 558   {
 559     frameCallback.mActorIds.PushBack( i.second );
 560   }
 561
 562   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 563
 564   application.SendNotification();
 565   application.Render();
 566
 567   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 568
 569   for( char i = 'A'; i <= 'H'; ++i )
 570   {
 571     DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
 572     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
 573   }
 574
 575   // Render again to make sure it still gets called and gives the correct values (in case any optimisations break this)
 576   frameCallback.mCalled = false;
 577
 578   application.SendNotification();
 579   application.Render();
 580
 581   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 582
 583   for( char i = 'A'; i <= 'H'; ++i )
 584   {
 585     DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
 586     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
 587   }
 588
 589   END_TEST;
 590 }
 591
 592 int UtcDaliFrameCallbackCheckActorNotAdded(void)
 593 {
 594   TestApplication application;
 595
 596   Actor actor = Actor::New();
 597   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 598   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 599   actor.SetSize( 200, 300 );
 600
 601   Stage stage = Stage::GetCurrent();
 602   FrameCallbackOneActor frameCallback( actor.GetId() );
 603   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 604
 605   application.SendNotification();
 606   application.Render();
 607
 608   // All should be default constructed objects
 609   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
 610   DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, Vector3::ZERO, TEST_LOCATION );
 611   DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3::ZERO, TEST_LOCATION );
 612   DALI_TEST_EQUALS( frameCallback.mColor, Vector4::ZERO, TEST_LOCATION );
 613   DALI_TEST_EQUALS( frameCallback.mScale, Vector3::ZERO, TEST_LOCATION );
 614
 615   END_TEST;
 616 }
 617
 618 int UtcDaliFrameCallbackInvalidActorId(void)
 619 {
 620   // Test to ensure that there are no issues when trying to use the update-proxy methods with an invalid actor ID.
 621
 622   TestApplication application;
 623   Stage stage = Stage::GetCurrent();
 624
 625   FrameCallbackActorIdCheck frameCallback( 10000 );
 626   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 627
 628   application.SendNotification();
 629   application.Render();
 630
 631   // Invalid Actor ID so all the methods should not return successfully.
 632
 633   DALI_TEST_EQUALS( frameCallback.mCalled,                        true,  TEST_LOCATION );
 634   DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess,            false, TEST_LOCATION );
 635   DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess,        false, TEST_LOCATION );
 636   DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess,           false, TEST_LOCATION );
 637   DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess,           false, TEST_LOCATION );
 638   DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION );
 639   DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess,            false, TEST_LOCATION );
 640   DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess,        false, TEST_LOCATION );
 641   DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess,           false, TEST_LOCATION );
 642   DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess,           false, TEST_LOCATION );
 643   DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess,           false, TEST_LOCATION );
 644   DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess,       false, TEST_LOCATION );
 645   DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess,          false, TEST_LOCATION );
 646   DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess,          false, TEST_LOCATION );
 647
 648   END_TEST;
 649 }
 650
 651 int UtcDaliFrameCallbackActorRemovedAndAdded(void)
 652 {
 653   // Test to ensure that we do not call methods on actors that have been removed on the stage
 654   // and then re-start calling the required methods if that actor is re-added back to the stage
 655
 656   TestApplication application;
 657   Stage stage = Stage::GetCurrent();
 658
 659   Actor actor = Actor::New();
 660   stage.Add( actor );
 661
 662   FrameCallbackActorIdCheck frameCallback( actor.GetId() );
 663   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 664
 665   application.SendNotification();
 666   application.Render();
 667
 668   // All methods should return successfully.
 669
 670   DALI_TEST_EQUALS( frameCallback.mCalled,                        true, TEST_LOCATION );
 671   DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess,            true, TEST_LOCATION );
 672   DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess,        true, TEST_LOCATION );
 673   DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess,           true, TEST_LOCATION );
 674   DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess,           true, TEST_LOCATION );
 675   DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION );
 676   DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess,            true, TEST_LOCATION );
 677   DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess,        true, TEST_LOCATION );
 678   DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess,           true, TEST_LOCATION );
 679   DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess,           true, TEST_LOCATION );
 680   DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess,           true, TEST_LOCATION );
 681   DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess,       true, TEST_LOCATION );
 682   DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess,          true, TEST_LOCATION );
 683   DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess,          true, TEST_LOCATION );
 684   frameCallback.Reset();
 685
 686   // Remove the actor from stage, the methods should not return successfully.
 687
 688   stage.Remove( actor );
 689
 690   application.SendNotification();
 691   application.Render();
 692
 693   DALI_TEST_EQUALS( frameCallback.mCalled,                        true,  TEST_LOCATION );
 694   DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess,            false, TEST_LOCATION );
 695   DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess,        false, TEST_LOCATION );
 696   DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess,           false, TEST_LOCATION );
 697   DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess,           false, TEST_LOCATION );
 698   DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION );
 699   DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess,            false, TEST_LOCATION );
 700   DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess,        false, TEST_LOCATION );
 701   DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess,           false, TEST_LOCATION );
 702   DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess,           false, TEST_LOCATION );
 703   DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess,           false, TEST_LOCATION );
 704   DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess,       false, TEST_LOCATION );
 705   DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess,          false, TEST_LOCATION );
 706   DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess,          false, TEST_LOCATION );
 707   frameCallback.Reset();
 708
 709   // Re-add the actor back to the stage, all the methods should once again, return successfully.
 710
 711   stage.Add( actor );
 712
 713   application.SendNotification();
 714   application.Render();
 715
 716   DALI_TEST_EQUALS( frameCallback.mCalled,                        true, TEST_LOCATION );
 717   DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess,            true, TEST_LOCATION );
 718   DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess,        true, TEST_LOCATION );
 719   DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess,           true, TEST_LOCATION );
 720   DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess,           true, TEST_LOCATION );
 721   DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION );
 722   DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess,            true, TEST_LOCATION );
 723   DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess,        true, TEST_LOCATION );
 724   DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess,           true, TEST_LOCATION );
 725   DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess,           true, TEST_LOCATION );
 726   DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess,           true, TEST_LOCATION );
 727   DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess,       true, TEST_LOCATION );
 728   DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess,          true, TEST_LOCATION );
 729   DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess,          true, TEST_LOCATION );
 730
 731   END_TEST;
 732 }
 733
 734 int UtcDaliFrameCallbackMultipleCallbacks(void)
 735 {
 736   // Test to ensure multiple frame-callbacks work as expected
 737
 738   TestApplication application;
 739   Stage stage = Stage::GetCurrent();
 740
 741   Actor actor = Actor::New();
 742   stage.Add( actor );
 743
 744   FrameCallbackBasic frameCallback1;
 745   FrameCallbackBasic frameCallback2;
 746   DevelStage::AddFrameCallback( stage, frameCallback1, stage.GetRootLayer() );
 747   DevelStage::AddFrameCallback( stage, frameCallback2, stage.GetRootLayer() );
 748
 749   application.SendNotification();
 750   application.Render();
 751
 752   DALI_TEST_EQUALS( frameCallback1.mCalled, true,  TEST_LOCATION );
 753   DALI_TEST_EQUALS( frameCallback2.mCalled, true,  TEST_LOCATION );
 754   frameCallback1.Reset();
 755   frameCallback2.Reset();
 756
 757   // Remove the second frame-callback, only the first should be called
 758
 759   DevelStage::RemoveFrameCallback( stage, frameCallback2 );
 760
 761   application.SendNotification();
 762   application.Render();
 763
 764   DALI_TEST_EQUALS( frameCallback1.mCalled, true,  TEST_LOCATION );
 765   DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
 766   frameCallback1.Reset();
 767   frameCallback2.Reset();
 768
 769   // Re-add the second frame-callback and remove the first, only the second should be called
 770
 771   DevelStage::AddFrameCallback( stage, frameCallback2, stage.GetRootLayer() );
 772   DevelStage::RemoveFrameCallback( stage, frameCallback1 );
 773
 774   application.SendNotification();
 775   application.Render();
 776
 777   DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
 778   DALI_TEST_EQUALS( frameCallback2.mCalled, true,  TEST_LOCATION );
 779   frameCallback1.Reset();
 780   frameCallback2.Reset();
 781
 782   // Attempt removal of the first frame-callback again, should be a no-op and yield the exact same results as the last run
 783   DevelStage::RemoveFrameCallback( stage, frameCallback1 );
 784
 785   application.SendNotification();
 786   application.Render();
 787
 788   DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
 789   DALI_TEST_EQUALS( frameCallback2.mCalled, true,  TEST_LOCATION );
 790   frameCallback1.Reset();
 791   frameCallback2.Reset();
 792
 793   // Remove the second frame-callback as well, neither should be called
 794   DevelStage::RemoveFrameCallback( stage, frameCallback2 );
 795
 796   application.SendNotification();
 797   application.Render();
 798
 799   DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
 800   DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
 801
 802   END_TEST;
 803 }
 804
 805 int UtcDaliFrameCallbackActorDestroyed(void)
 806 {
 807   TestApplication application;
 808   Stage stage = Stage::GetCurrent();
 809
 810   Actor actor = Actor::New();
 811   stage.Add( actor );
 812
 813   FrameCallbackBasic frameCallback1;
 814   FrameCallbackBasic frameCallback2;
 815   DevelStage::AddFrameCallback( stage, frameCallback1, actor );
 816   DevelStage::AddFrameCallback( stage, frameCallback2, actor );
 817
 818   application.SendNotification();
 819   application.Render();
 820
 821   DALI_TEST_EQUALS( frameCallback1.mCalled, true,  TEST_LOCATION );
 822   DALI_TEST_EQUALS( frameCallback2.mCalled, true,  TEST_LOCATION );
 823   frameCallback1.Reset();
 824   frameCallback2.Reset();
 825
 826   // Remove the second frame-callback, only the first should be called
 827
 828   DevelStage::RemoveFrameCallback( stage, frameCallback2 );
 829
 830   application.SendNotification();
 831   application.Render();
 832
 833   DALI_TEST_EQUALS( frameCallback1.mCalled, true,  TEST_LOCATION );
 834   DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
 835   frameCallback1.Reset();
 836   frameCallback2.Reset();
 837
 838   // Remove and destroy the actor, the first one should not be called either
 839   stage.Remove( actor );
 840   actor.Reset();
 841
 842   application.SendNotification();
 843   application.Render();
 844
 845   DALI_TEST_EQUALS( frameCallback1.mCalled, false,  TEST_LOCATION );
 846   DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
 847
 848   END_TEST;
 849 }