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