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

   1 /*
   2  * Copyright (c) 2019 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 "assert.h"
  19 #include <dali/public-api/dali-core.h>
  20 #include <string>
  21 #include <cfloat>   // For FLT_MAX
  22 #include <dali/devel-api/actors/actor-devel.h>
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <dali/integration-api/events/hover-event-integ.h>
  25 #include <dali-test-suite-utils.h>
  26 #include <mesh-builder.h>
  27
  28 //& set: DaliActor
  29
  30 using std::string;
  31 using namespace Dali;
  32
  33
  34 void utc_dali_actor_startup(void)
  35 {
  36   test_return_value = TET_UNDEF;
  37 }
  38
  39 void utc_dali_actor_cleanup(void)
  40 {
  41   test_return_value = TET_PASS;
  42 }
  43
  44 namespace
  45 {
  46 bool gTouchCallBackCalled=false;
  47 bool gTouchCallBackCalled2=false;
  48 bool gTouchCallBackCalled3=false;
  49
  50 bool gHoverCallBackCalled=false;
  51
  52 static bool gTestConstraintCalled;
  53
  54 LayoutDirection::Type gLayoutDirectionType;
  55
  56 struct TestConstraint
  57 {
  58   void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ )
  59   {
  60     gTestConstraintCalled = true;
  61   }
  62 };
  63
  64 /**
  65  * TestConstraint reference.
  66  * When constraint is called, the resultRef is updated
  67  * with the value supplied.
  68  */
  69 template<typename T>
  70 struct TestConstraintRef
  71 {
  72   TestConstraintRef(unsigned int& resultRef, unsigned int value)
  73   : mResultRef(resultRef),
  74     mValue(value)
  75   {
  76   }
  77
  78   void operator()( T& current, const PropertyInputContainer& /* inputs */ )
  79   {
  80     mResultRef = mValue;
  81   }
  82
  83   unsigned int& mResultRef;
  84   unsigned int mValue;
  85 };
  86
  87 static bool TestCallback(Actor actor, const TouchEvent& event)
  88 {
  89   gTouchCallBackCalled = true;
  90   return false;
  91   END_TEST;
  92 }
  93
  94 static bool TestTouchCallback(Actor actor, const TouchData& touchData )
  95 {
  96   gTouchCallBackCalled = true;
  97   return true;
  98   END_TEST;
  99 }
 100
 101 static bool TestTouchCallback2(Actor actor, const TouchData& touchData )
 102 {
 103   gTouchCallBackCalled2 = true;
 104   return true;
 105   END_TEST;
 106 }
 107
 108 static bool TestTouchCallback3(Actor actor, const TouchData& touchData )
 109 {
 110   gTouchCallBackCalled3 = true;
 111   return true;
 112   END_TEST;
 113 }
 114
 115 static void ResetTouchCallbacks()
 116 {
 117   gTouchCallBackCalled = false;
 118   gTouchCallBackCalled2 = false;
 119   gTouchCallBackCalled3 = false;
 120 }
 121
 122 static bool TestCallback3(Actor actor, const HoverEvent& event)
 123 {
 124   gHoverCallBackCalled = true;
 125   return false;
 126   END_TEST;
 127 }
 128
 129 // validation stuff for onstage & offstage signals
 130 static std::vector< std::string > gActorNamesOnOffStage;
 131 static int gOnStageCallBackCalled;
 132 void OnStageCallback( Actor actor )
 133 {
 134   ++gOnStageCallBackCalled;
 135   gActorNamesOnOffStage.push_back( actor.GetName() );
 136   DALI_TEST_CHECK( actor.OnStage() == true );
 137 }
 138 static int gOffStageCallBackCalled;
 139 void OffStageCallback( Actor actor )
 140 {
 141   ++gOffStageCallBackCalled;
 142   gActorNamesOnOffStage.push_back( actor.GetName() );
 143   DALI_TEST_CHECK( actor.OnStage() == false );
 144 }
 145
 146 struct PositionComponentConstraint
 147 {
 148   PositionComponentConstraint(){}
 149
 150   void operator()( Vector3& pos, const PropertyInputContainer& inputs )
 151   {
 152     const Matrix& m = inputs[0]->GetMatrix();
 153     Vector3 scale;
 154     Quaternion rot;
 155     m.GetTransformComponents(pos, rot, scale);
 156   }
 157 };
 158
 159 struct OrientationComponentConstraint
 160 {
 161   OrientationComponentConstraint(){}
 162
 163   void operator()( Quaternion& orientation, const PropertyInputContainer& inputs )
 164   {
 165     const Quaternion& parentOrientation = inputs[0]->GetQuaternion();
 166     Vector3 pos, scale;
 167     Quaternion rot;
 168     orientation = parentOrientation;
 169   }
 170 };
 171 // OnRelayout
 172
 173 static bool gOnRelayoutCallBackCalled = false;
 174 static std::vector< std::string > gActorNamesRelayout;
 175
 176 void OnRelayoutCallback( Actor actor )
 177 {
 178   gOnRelayoutCallBackCalled = true;
 179   gActorNamesRelayout.push_back( actor.GetName() );
 180 }
 181
 182 struct VisibilityChangedFunctorData
 183 {
 184   VisibilityChangedFunctorData()
 185   : actor(),
 186     visible( false ),
 187     type( DevelActor::VisibilityChange::SELF ),
 188     called( false )
 189   {
 190   }
 191
 192   void Reset()
 193   {
 194     actor.Reset();
 195     visible = false;
 196     type = DevelActor::VisibilityChange::SELF;
 197     called = false;
 198   }
 199
 200   void Check( bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char * location )
 201   {
 202     DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
 203     DALI_TEST_EQUALS( actor, compareActor, TEST_INNER_LOCATION( location ) );
 204     DALI_TEST_EQUALS( visible, compareVisible, TEST_INNER_LOCATION( location ) );
 205     DALI_TEST_EQUALS( (int)type, (int)compareType, TEST_INNER_LOCATION( location ) );
 206   }
 207
 208   void Check( bool compareCalled, const std::string& location )
 209   {
 210     DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
 211   }
 212
 213   Actor actor;
 214   bool visible;
 215   DevelActor::VisibilityChange::Type type;
 216   bool called;
 217 };
 218
 219 struct VisibilityChangedFunctor
 220 {
 221   VisibilityChangedFunctor( VisibilityChangedFunctorData& dataVar ) : data( dataVar ) { }
 222
 223   void operator()( Actor actor, bool visible, DevelActor::VisibilityChange::Type type )
 224   {
 225     data.actor = actor;
 226     data.visible = visible;
 227     data.type = type;
 228     data.called = true;
 229   }
 230
 231   VisibilityChangedFunctorData& data;
 232 };
 233
 234
 235 struct VisibilityChangedVoidFunctor
 236 {
 237   VisibilityChangedVoidFunctor(bool& signalCalled)
 238   : mSignalCalled( signalCalled )
 239   { }
 240
 241   void operator()()
 242   {
 243     mSignalCalled  = true;
 244   }
 245
 246   bool& mSignalCalled;
 247 };
 248
 249 struct ChildOrderChangedFunctor
 250 {
 251   ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
 252   : mSignalCalled( signalCalled ),
 253     mActor( actor )
 254   { }
 255
 256   void operator()( Actor actor )
 257   {
 258     mSignalCalled  = true;
 259     mActor = actor;
 260   }
 261
 262   bool& mSignalCalled;
 263   Actor& mActor;
 264 };
 265
 266 struct CulledPropertyNotificationFunctor
 267 {
 268   CulledPropertyNotificationFunctor( bool& signalCalled, PropertyNotification& propertyNotification )
 269   : mSignalCalled( signalCalled ),
 270     mPropertyNotification( propertyNotification )
 271   { }
 272
 273   void operator()( PropertyNotification& source )
 274   {
 275     mSignalCalled  = true;
 276     mPropertyNotification = source;
 277   }
 278
 279   bool& mSignalCalled;
 280   PropertyNotification& mPropertyNotification;
 281 };
 282
 283 } // anonymous namespace
 284
 285
 286 //& purpose: Testing New API
 287 int UtcDaliActorNew(void)
 288 {
 289   TestApplication application;
 290
 291   Actor actor = Actor::New();
 292
 293   DALI_TEST_CHECK(actor);
 294   END_TEST;
 295 }
 296
 297 //& purpose: Testing Dali::Actor::DownCast()
 298 int UtcDaliActorDownCastP(void)
 299 {
 300   TestApplication application;
 301   tet_infoline("Testing Dali::Actor::DownCast()");
 302
 303   Actor actor = Actor::New();
 304   BaseHandle object(actor);
 305   Actor actor2 = Actor::DownCast(object);
 306   DALI_TEST_CHECK(actor2);
 307   END_TEST;
 308 }
 309
 310 //& purpose: Testing Dali::Actor::DownCast()
 311 int UtcDaliActorDownCastN(void)
 312 {
 313   TestApplication application;
 314   tet_infoline("Testing Dali::Actor::DownCast()");
 315
 316   BaseHandle unInitializedObject;
 317   Actor actor = Actor::DownCast(unInitializedObject);
 318   DALI_TEST_CHECK(!actor);
 319   END_TEST;
 320 }
 321
 322 //& purpose: Testing Dali::Actor::GetName()
 323 int UtcDaliActorGetName(void)
 324 {
 325   TestApplication application;
 326
 327   Actor actor = Actor::New();
 328
 329   DALI_TEST_CHECK(actor.GetName().empty());
 330   END_TEST;
 331 }
 332
 333 //& purpose: Testing Dali::Actor::SetName()
 334 int UtcDaliActorSetName(void)
 335 {
 336   TestApplication application;
 337
 338   string str("ActorName");
 339   Actor actor = Actor::New();
 340
 341   actor.SetName(str);
 342   DALI_TEST_CHECK(actor.GetName() == str);
 343   END_TEST;
 344 }
 345
 346 int UtcDaliActorGetId(void)
 347 {
 348   tet_infoline("Testing Dali::Actor::UtcDaliActorGetId()");
 349   TestApplication application;
 350
 351   Actor first = Actor::New();
 352   Actor second = Actor::New();
 353   Actor third = Actor::New();
 354
 355   DALI_TEST_CHECK(first.GetId() != second.GetId());
 356   DALI_TEST_CHECK(second.GetId() != third.GetId());
 357   END_TEST;
 358 }
 359
 360 int UtcDaliActorIsRoot(void)
 361 {
 362   TestApplication application;
 363
 364   Actor actor = Actor::New();
 365   DALI_TEST_CHECK(!actor.IsRoot());
 366
 367   // get the root layer
 368   actor = Stage::GetCurrent().GetLayer( 0 );
 369   DALI_TEST_CHECK( actor.IsRoot() );
 370   END_TEST;
 371 }
 372
 373 int UtcDaliActorOnStage(void)
 374 {
 375   TestApplication application;
 376
 377   Actor actor = Actor::New();
 378   DALI_TEST_CHECK( !actor.OnStage() );
 379
 380   // get the root layer
 381   actor = Stage::GetCurrent().GetLayer( 0 );
 382   DALI_TEST_CHECK( actor.OnStage() );
 383   END_TEST;
 384 }
 385
 386 int UtcDaliActorIsLayer(void)
 387 {
 388   TestApplication application;
 389
 390   Actor actor = Actor::New();
 391   DALI_TEST_CHECK( !actor.IsLayer() );
 392
 393   // get the root layer
 394   actor = Stage::GetCurrent().GetLayer( 0 );
 395   DALI_TEST_CHECK( actor.IsLayer() );
 396   END_TEST;
 397 }
 398
 399 int UtcDaliActorGetLayer(void)
 400 {
 401   TestApplication application;
 402
 403   Actor actor = Actor::New();
 404   Stage::GetCurrent().Add(actor);
 405   Layer layer = actor.GetLayer();
 406
 407   DALI_TEST_CHECK(layer);
 408
 409   // get the root layers layer
 410   actor = Stage::GetCurrent().GetLayer( 0 );
 411   DALI_TEST_CHECK( actor.GetLayer() );
 412   END_TEST;
 413 }
 414
 415 int UtcDaliActorAddP(void)
 416 {
 417   tet_infoline("Testing Actor::Add");
 418   TestApplication application;
 419
 420   Actor parent = Actor::New();
 421   Actor child = Actor::New();
 422
 423   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 424
 425   parent.Add(child);
 426
 427   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 428
 429   Actor parent2 = Actor::New();
 430   parent2.Add( child );
 431
 432   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 433   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 434
 435   // try Adding to same parent again, works
 436   parent2.Add( child );
 437   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 438
 439   // try reparenting an orphaned child
 440   {
 441     Actor temporaryParent = Actor::New();
 442     temporaryParent.Add( child );
 443     DALI_TEST_EQUALS( parent2.GetChildCount(), 0u, TEST_LOCATION );
 444   }
 445   // temporaryParent has now died, reparent the orphaned child
 446   parent2.Add( child );
 447   DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 448
 449   END_TEST;
 450 }
 451
 452 int UtcDaliActorAddN(void)
 453 {
 454   tet_infoline("Testing Actor::Add");
 455   TestApplication application;
 456
 457   Actor child = Actor::New();
 458
 459   Actor parent2 = Actor::New();
 460   parent2.Add( child );
 461
 462   // try illegal Add
 463   try
 464   {
 465     parent2.Add( parent2 );
 466     tet_printf("Assertion test failed - no Exception\n" );
 467     tet_result(TET_FAIL);
 468   }
 469   catch(Dali::DaliException& e)
 470   {
 471     DALI_TEST_PRINT_ASSERT( e );
 472     DALI_TEST_ASSERT(e, "this != &child", TEST_LOCATION);
 473     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 474   }
 475   catch(...)
 476   {
 477     tet_printf("Assertion test failed - wrong Exception\n" );
 478     tet_result(TET_FAIL);
 479   }
 480
 481   // try reparenting root
 482   try
 483   {
 484     parent2.Add( Stage::GetCurrent().GetLayer( 0 ) );
 485     tet_printf("Assertion test failed - no Exception\n" );
 486     tet_result(TET_FAIL);
 487   }
 488   catch(Dali::DaliException& e)
 489   {
 490     DALI_TEST_PRINT_ASSERT( e );
 491     DALI_TEST_ASSERT(e, "!child.IsRoot()", TEST_LOCATION);
 492     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 493   }
 494   catch(...)
 495   {
 496     tet_printf("Assertion test failed - wrong Exception\n" );
 497     tet_result(TET_FAIL);
 498   }
 499
 500   // try Add empty
 501   try
 502   {
 503     Actor empty;
 504     parent2.Add( empty );
 505     tet_printf("Assertion test failed - no Exception\n" );
 506     tet_result(TET_FAIL);
 507   }
 508   catch(Dali::DaliException& e)
 509   {
 510     DALI_TEST_PRINT_ASSERT( e );
 511     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 512     DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
 513   }
 514   catch(...)
 515   {
 516     tet_printf("Assertion test failed - wrong Exception\n" );
 517     tet_result(TET_FAIL);
 518   }
 519
 520   END_TEST;
 521 }
 522
 523 int UtcDaliActorRemoveN(void)
 524 {
 525   tet_infoline("Testing Actor::Remove");
 526   TestApplication application;
 527
 528   Actor parent = Actor::New();
 529   Actor child = Actor::New();
 530   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 531
 532   parent.Add(child);
 533   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 534
 535   parent.Remove(child);
 536   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 537
 538   // remove again, no problem
 539   parent.Remove(child);
 540   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
 541
 542   // add child back
 543   parent.Add(child);
 544   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 545   // try Remove self, its a no-op
 546   parent.Remove( parent );
 547   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 548
 549   // try Remove empty
 550   try
 551   {
 552     Actor empty;
 553     parent.Remove( empty );
 554     tet_printf("Assertion test failed - no Exception\n" );
 555     tet_result(TET_FAIL);
 556   }
 557   catch(Dali::DaliException& e)
 558   {
 559     DALI_TEST_PRINT_ASSERT( e );
 560     DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
 561     DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
 562   }
 563   catch(...)
 564   {
 565     tet_printf("Assertion test failed - wrong Exception\n" );
 566     tet_result(TET_FAIL);
 567   }
 568   END_TEST;
 569 }
 570
 571 int UtcDaliActorRemoveP(void)
 572 {
 573   TestApplication application;
 574
 575   Actor parent = Actor::New();
 576   Actor child = Actor::New();
 577   Actor random = Actor::New();
 578
 579   Stage::GetCurrent().Add( parent );
 580
 581   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 582
 583   parent.Add(child);
 584
 585   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 586
 587   parent.Remove(random);
 588
 589   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 590
 591   Stage::GetCurrent().Remove( parent );
 592
 593   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 594   END_TEST;
 595 }
 596
 597 int UtcDaliActorGetChildCount(void)
 598 {
 599   TestApplication application;
 600
 601   Actor parent = Actor::New();
 602   Actor child = Actor::New();
 603
 604   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 605
 606   parent.Add(child);
 607
 608   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 609   END_TEST;
 610 }
 611
 612 int UtcDaliActorGetChildren01(void)
 613 {
 614   TestApplication application;
 615
 616   Actor parent = Actor::New();
 617   Actor first  = Actor::New();
 618   Actor second = Actor::New();
 619   Actor third  = Actor::New();
 620
 621   parent.Add(first);
 622   parent.Add(second);
 623   parent.Add(third);
 624
 625   DALI_TEST_CHECK(parent.GetChildAt(0) == first);
 626   DALI_TEST_CHECK(parent.GetChildAt(1) == second);
 627   DALI_TEST_CHECK(parent.GetChildAt(2) == third);
 628   END_TEST;
 629 }
 630
 631 int UtcDaliActorGetChildren02(void)
 632 {
 633   TestApplication application;
 634
 635   Actor parent = Actor::New();
 636   Actor first  = Actor::New();
 637   Actor second = Actor::New();
 638   Actor third  = Actor::New();
 639
 640   parent.Add(first);
 641   parent.Add(second);
 642   parent.Add(third);
 643
 644   const Actor& constParent = parent;
 645
 646   DALI_TEST_CHECK(constParent.GetChildAt(0) == first);
 647   DALI_TEST_CHECK(constParent.GetChildAt(1) == second);
 648   DALI_TEST_CHECK(constParent.GetChildAt(2) == third);
 649   END_TEST;
 650 }
 651
 652 int UtcDaliActorGetParent01(void)
 653 {
 654   TestApplication application;
 655
 656   Actor parent = Actor::New();
 657   Actor child = Actor::New();
 658
 659   parent.Add(child);
 660
 661   DALI_TEST_CHECK(child.GetParent() == parent);
 662   END_TEST;
 663 }
 664
 665 int UtcDaliActorGetParent02(void)
 666 {
 667   TestApplication application;
 668
 669   Actor actor = Actor::New();
 670
 671   DALI_TEST_CHECK(!actor.GetParent());
 672   END_TEST;
 673 }
 674
 675 int UtcDaliActorCustomProperty(void)
 676 {
 677   TestApplication application;
 678
 679   Actor actor = Actor::New();
 680   Stage::GetCurrent().Add( actor );
 681
 682   float startValue(1.0f);
 683   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 684   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 685
 686   application.SendNotification();
 687   application.Render(0);
 688   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 689
 690   actor.SetProperty( index, 5.0f );
 691
 692   application.SendNotification();
 693   application.Render(0);
 694   DALI_TEST_CHECK( actor.GetProperty<float>(index) == 5.0f );
 695   END_TEST;
 696 }
 697
 698 int UtcDaliActorCustomPropertyIntToFloat(void)
 699 {
 700   TestApplication application;
 701
 702   Actor actor = Actor::New();
 703   Stage::GetCurrent().Add( actor );
 704
 705   float startValue(5.0f);
 706   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 707   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 708
 709   application.SendNotification();
 710   application.Render(0);
 711   DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
 712
 713   actor.SetProperty( index, int(1) );
 714
 715   application.SendNotification();
 716   application.Render(0);
 717   DALI_TEST_CHECK( actor.GetProperty<float>(index) == 1.0f );
 718   END_TEST;
 719 }
 720
 721 int UtcDaliActorCustomPropertyFloatToInt(void)
 722 {
 723   TestApplication application;
 724
 725   Actor actor = Actor::New();
 726   Stage::GetCurrent().Add( actor );
 727
 728   int startValue(5);
 729   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
 730   DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
 731
 732   application.SendNotification();
 733   application.Render(0);
 734   DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
 735
 736   actor.SetProperty( index, float(1.5) );
 737
 738   application.SendNotification();
 739   application.Render(0);
 740   DALI_TEST_CHECK( actor.GetProperty<int>(index) == 1 );
 741   END_TEST;
 742 }
 743
 744 int UtcDaliActorSetParentOrigin(void)
 745 {
 746   TestApplication application;
 747
 748   Actor actor = Actor::New();
 749
 750   Vector3 vector(0.7f, 0.8f, 0.9f);
 751   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 752
 753   actor.SetParentOrigin(vector);
 754
 755   // flush the queue and render once
 756   application.SendNotification();
 757   application.Render();
 758
 759   DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
 760
 761   Stage::GetCurrent().Add( actor );
 762
 763   actor.SetParentOrigin( Vector3( 0.1f, 0.2f, 0.3f ) );
 764
 765   // flush the queue and render once
 766   application.SendNotification();
 767   application.Render();
 768
 769   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentParentOrigin(), TEST_LOCATION );
 770
 771   Stage::GetCurrent().Remove( actor );
 772   END_TEST;
 773 }
 774
 775 int UtcDaliActorSetParentOriginIndividual(void)
 776 {
 777   TestApplication application;
 778
 779   Actor actor = Actor::New();
 780
 781   Vector3 vector(0.7f, 0.8f, 0.9f);
 782   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 783
 784   actor.SetProperty( Actor::Property::PARENT_ORIGIN_X, vector.x );
 785
 786   // flush the queue and render once
 787   application.SendNotification();
 788   application.Render();
 789
 790   DALI_TEST_EQUALS( vector.x, actor.GetCurrentParentOrigin().x, TEST_LOCATION );
 791
 792   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Y, vector.y );
 793
 794   // flush the queue and render once
 795   application.SendNotification();
 796   application.Render();
 797
 798   DALI_TEST_EQUALS( vector.y, actor.GetCurrentParentOrigin().y, TEST_LOCATION );
 799
 800   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Z, vector.z );
 801
 802   // flush the queue and render once
 803   application.SendNotification();
 804   application.Render();
 805
 806   DALI_TEST_EQUALS( vector.z, actor.GetCurrentParentOrigin().z, TEST_LOCATION );
 807
 808   END_TEST;
 809 }
 810
 811 int UtcDaliActorGetCurrentParentOrigin(void)
 812 {
 813   TestApplication application;
 814
 815   Actor actor = Actor::New();
 816
 817   Vector3 vector(0.7f, 0.8f, 0.9f);
 818   DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
 819
 820   actor.SetParentOrigin(vector);
 821
 822   // flush the queue and render once
 823   application.SendNotification();
 824   application.Render();
 825
 826   DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
 827   END_TEST;
 828 }
 829
 830 int UtcDaliActorSetAnchorPoint(void)
 831 {
 832   TestApplication application;
 833
 834   Actor actor = Actor::New();
 835
 836   Vector3 vector(0.7f, 0.8f, 0.9f);
 837   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 838
 839   actor.SetAnchorPoint(vector);
 840
 841   // flush the queue and render once
 842   application.SendNotification();
 843   application.Render();
 844
 845   DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
 846
 847   Stage::GetCurrent().Add( actor );
 848
 849   actor.SetAnchorPoint( Vector3( 0.1f, 0.2f, 0.3f ) );
 850   // flush the queue and render once
 851   application.SendNotification();
 852   application.Render();
 853
 854   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentAnchorPoint(), TEST_LOCATION );
 855
 856   Stage::GetCurrent().Remove( actor );
 857   END_TEST;
 858 }
 859
 860 int UtcDaliActorSetAnchorPointIndividual(void)
 861 {
 862   TestApplication application;
 863
 864   Actor actor = Actor::New();
 865
 866   Vector3 vector(0.7f, 0.8f, 0.9f);
 867   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 868
 869   actor.SetProperty( Actor::Property::ANCHOR_POINT_X, vector.x );
 870
 871   // flush the queue and render once
 872   application.SendNotification();
 873   application.Render();
 874
 875   DALI_TEST_EQUALS( vector.x, actor.GetCurrentAnchorPoint().x, TEST_LOCATION );
 876
 877   actor.SetProperty( Actor::Property::ANCHOR_POINT_Y, vector.y );
 878
 879   // flush the queue and render once
 880   application.SendNotification();
 881   application.Render();
 882
 883   DALI_TEST_EQUALS( vector.y, actor.GetCurrentAnchorPoint().y, TEST_LOCATION );
 884
 885   actor.SetProperty( Actor::Property::ANCHOR_POINT_Z, vector.z );
 886
 887   // flush the queue and render once
 888   application.SendNotification();
 889   application.Render();
 890
 891   DALI_TEST_EQUALS( vector.z, actor.GetCurrentAnchorPoint().z, TEST_LOCATION );
 892
 893   END_TEST;
 894 }
 895
 896 int UtcDaliActorGetCurrentAnchorPoint(void)
 897 {
 898   TestApplication application;
 899
 900   Actor actor = Actor::New();
 901
 902   Vector3 vector(0.7f, 0.8f, 0.9f);
 903   DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
 904
 905   actor.SetAnchorPoint(vector);
 906
 907   // flush the queue and render once
 908   application.SendNotification();
 909   application.Render();
 910
 911   DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
 912   END_TEST;
 913 }
 914
 915 // SetSize(float width, float height)
 916 int UtcDaliActorSetSize01(void)
 917 {
 918   TestApplication application;
 919
 920   Actor actor = Actor::New();
 921   Vector3 vector(100.0f, 100.0f, 0.0f);
 922
 923   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
 924
 925   actor.SetSize(vector.x, vector.y);
 926
 927   // Immediately retrieve the size after setting
 928   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 929   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 930   DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 931   DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 932   DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 933
 934   // Flush the queue and render once
 935   application.SendNotification();
 936   application.Render();
 937
 938   // Check the size in the new frame
 939   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
 940
 941   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 942   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 943   DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 944   DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 945   DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 946
 947   // Check async behaviour
 948   currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
 949   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 950   DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
 951   DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
 952   DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
 953
 954   // Change the resize policy and check whether the size stays the same
 955   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 956
 957   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 958   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 959
 960   // Set a new size after resize policy is changed and check the new size
 961   actor.SetSize( Vector3( 0.1f, 0.2f, 0.0f ) );
 962
 963   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 964   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 965
 966   // Change the resize policy again and check whether the new size stays the same
 967   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 968
 969   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 970   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 971
 972   // Set another new size after resize policy is changed and check the new size
 973   actor.SetSize( Vector3( 50.0f, 60.0f, 0.0f ) );
 974
 975   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 976   DALI_TEST_EQUALS( currentSize, Vector3( 50.0f, 60.0f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 977
 978   END_TEST;
 979 }
 980
 981 // SetSize(float width, float height, float depth)
 982 int UtcDaliActorSetSize02(void)
 983 {
 984   TestApplication application;
 985
 986   Actor actor = Actor::New();
 987   Vector3 vector(100.0f, 100.0f, 100.0f);
 988
 989   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
 990
 991   actor.SetSize(vector.x, vector.y, vector.z);
 992
 993   // Immediately check the size after setting
 994   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
 995   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 996
 997   // flush the queue and render once
 998   application.SendNotification();
 999   application.Render();
1000
1001   // Check the size in the new frame
1002   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1003
1004   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1005   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1006
1007   END_TEST;
1008 }
1009
1010 // SetSize(Vector2 size)
1011 int UtcDaliActorSetSize03(void)
1012 {
1013   TestApplication application;
1014
1015   Actor actor = Actor::New();
1016   Vector3 vector(100.0f, 100.0f, 0.0f);
1017
1018   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1019
1020   actor.SetSize(Vector2(vector.x, vector.y));
1021
1022   // Immediately check the size after setting
1023   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1024   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1025
1026   // flush the queue and render once
1027   application.SendNotification();
1028   application.Render();
1029
1030   // Check the size in the new frame
1031   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1032
1033   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1034   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1035
1036   END_TEST;
1037 }
1038
1039 // SetSize(Vector3 size)
1040 int UtcDaliActorSetSize04(void)
1041 {
1042   TestApplication application;
1043
1044   Actor actor = Actor::New();
1045   Vector3 vector(100.0f, 100.0f, 100.0f);
1046
1047   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1048
1049   actor.SetSize(vector);
1050
1051   // Immediately check the size after setting
1052   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1053   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1054
1055   // flush the queue and render once
1056   application.SendNotification();
1057   application.Render();
1058
1059   // Check the size in the new frame
1060   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1061
1062   Stage::GetCurrent().Add( actor );
1063   actor.SetSize( Vector3( 0.1f, 0.2f, 0.3f ) );
1064
1065   // Immediately check the size after setting
1066   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1067   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
1068
1069   // flush the queue and render once
1070   application.SendNotification();
1071   application.Render();
1072
1073   // Check the size in the new frame
1074   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentSize(), TEST_LOCATION );
1075
1076   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
1077   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
1078
1079   Stage::GetCurrent().Remove( actor );
1080   END_TEST;
1081 }
1082
1083 int UtcDaliActorSetSizeIndividual(void)
1084 {
1085   TestApplication application;
1086
1087   Actor actor = Actor::New();
1088
1089   Vector3 vector(0.7f, 0.8f, 0.9f);
1090   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1091
1092   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
1093
1094   // Immediately check the width after setting
1095   float sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1096   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1097
1098   // flush the queue and render once
1099   application.SendNotification();
1100   application.Render();
1101
1102   // Check the width in the new frame
1103   DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
1104
1105   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1106   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1107
1108   actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
1109
1110   // Immediately check the height after setting
1111   float sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1112   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1113
1114   // flush the queue and render once
1115   application.SendNotification();
1116   application.Render();
1117
1118   // Check the height in the new frame
1119   DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
1120
1121   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1122   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1123
1124   actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
1125
1126   // Immediately check the depth after setting
1127   float sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1128   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1129
1130   // flush the queue and render once
1131   application.SendNotification();
1132   application.Render();
1133
1134   // Check the depth in the new frame
1135   DALI_TEST_EQUALS( vector.depth, actor.GetCurrentSize().depth, TEST_LOCATION );
1136
1137   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1138   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1139
1140   // Change the resize policy and check whether the size stays the same
1141   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
1142
1143   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1144   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1145
1146   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1147   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1148
1149   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1150   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1151
1152   // Change the resize policy again and check whether the size stays the same
1153   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
1154
1155   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
1156   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1157
1158   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
1159   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1160
1161   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
1162   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1163
1164   END_TEST;
1165 }
1166
1167 int UtcDaliActorSetSizeIndividual02(void)
1168 {
1169   TestApplication application;
1170
1171   Actor actor = Actor::New();
1172   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
1173   Stage::GetCurrent().Add( actor );
1174
1175   Vector3 vector( 100.0f, 200.0f, 400.0f );
1176   DALI_TEST_CHECK( vector != actor.GetCurrentSize() );
1177
1178   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
1179   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1180
1181   actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
1182   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1183
1184   actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
1185   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1186
1187   // flush the queue and render once
1188   application.SendNotification();
1189   application.Render();
1190
1191   // Check the width in the new frame
1192   DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
1193   DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
1194
1195   END_TEST;
1196 }
1197
1198
1199 int UtcDaliActorGetCurrentSize(void)
1200 {
1201   TestApplication application;
1202
1203   Actor actor = Actor::New();
1204   Vector3 vector(100.0f, 100.0f, 20.0f);
1205
1206   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1207
1208   actor.SetSize(vector);
1209
1210   // flush the queue and render once
1211   application.SendNotification();
1212   application.Render();
1213
1214   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1215   END_TEST;
1216 }
1217
1218 int UtcDaliActorGetNaturalSize(void)
1219 {
1220   TestApplication application;
1221
1222   Actor actor = Actor::New();
1223   Vector3 vector( 0.0f, 0.0f, 0.0f );
1224
1225   DALI_TEST_CHECK( actor.GetNaturalSize() == vector );
1226
1227   END_TEST;
1228 }
1229
1230 int UtcDaliActorGetCurrentSizeImmediate(void)
1231 {
1232   TestApplication application;
1233
1234   Actor actor = Actor::New();
1235   Vector3 vector(100.0f, 100.0f, 20.0f);
1236
1237   DALI_TEST_CHECK(vector != actor.GetTargetSize());
1238   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1239
1240   actor.SetSize(vector);
1241
1242   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1243   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
1244
1245   // flush the queue and render once
1246   application.SendNotification();
1247   application.Render();
1248
1249   DALI_TEST_CHECK(vector == actor.GetTargetSize());
1250   DALI_TEST_CHECK(vector == actor.GetCurrentSize());
1251
1252   // Animation
1253   // Build the animation
1254   const float durationSeconds = 2.0f;
1255   Animation animation = Animation::New( durationSeconds );
1256   const Vector3 targetValue( 10.0f, 20.0f, 30.0f );
1257   animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
1258
1259   DALI_TEST_CHECK( actor.GetTargetSize() == vector );
1260
1261   // Start the animation
1262   animation.Play();
1263
1264   application.SendNotification();
1265   application.Render( static_cast<unsigned int>( durationSeconds * 1000.0f ) );
1266
1267   DALI_TEST_CHECK( actor.GetTargetSize() == targetValue );
1268
1269   END_TEST;
1270 }
1271
1272 int UtcDaliActorCalculateScreenExtents(void)
1273 {
1274   TestApplication application;
1275
1276   Actor actor = Actor::New();
1277
1278   actor.SetPosition(Vector3(2.0f, 2.0f, 16.0f));
1279   actor.SetSize(Vector3{ 1.0f, 1.0f, 1.0f });
1280
1281   application.SendNotification();
1282   application.Render();
1283
1284   auto expectedExtent = Rect<>{ -0.5f, -0.5f, 1.0f, 1.0f };
1285   auto actualExtent = DevelActor::CalculateScreenExtents( actor );
1286   DALI_TEST_EQUALS( expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1287   DALI_TEST_EQUALS( expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1288   DALI_TEST_EQUALS( expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1289   DALI_TEST_EQUALS( expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1290
1291   Stage::GetCurrent().Remove( actor );
1292   END_TEST;
1293 }
1294
1295 // SetPosition(float x, float y)
1296 int UtcDaliActorSetPosition01(void)
1297 {
1298   TestApplication application;
1299
1300   Actor actor = Actor::New();
1301
1302   // Set to random to start off with
1303   actor.SetPosition(Vector3(120.0f, 120.0f, 0.0f));
1304
1305   Vector3 vector(100.0f, 100.0f, 0.0f);
1306
1307   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1308
1309   actor.SetPosition(vector.x, vector.y);
1310   // flush the queue and render once
1311   application.SendNotification();
1312   application.Render();
1313   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1314
1315   Stage::GetCurrent().Add( actor );
1316   actor.SetPosition( Vector3( 0.1f, 0.2f, 0.3f ) );
1317   // flush the queue and render once
1318   application.SendNotification();
1319   application.Render();
1320   DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentPosition(), TEST_LOCATION );
1321
1322   actor.SetX( 1.0f );
1323   actor.SetY( 1.1f );
1324   actor.SetZ( 1.2f );
1325   // flush the queue and render once
1326   application.SendNotification();
1327   application.Render();
1328   DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentPosition(), TEST_LOCATION );
1329
1330   actor.TranslateBy( Vector3( 0.1f, 0.1f, 0.1f ) );
1331   // flush the queue and render once
1332   application.SendNotification();
1333   application.Render();
1334   DALI_TEST_EQUALS( Vector3( 1.1f, 1.2f, 1.3f ), actor.GetCurrentPosition(), Math::MACHINE_EPSILON_10000, TEST_LOCATION );
1335
1336   Stage::GetCurrent().Remove( actor );
1337   END_TEST;
1338 }
1339
1340 // SetPosition(float x, float y, float z)
1341 int UtcDaliActorSetPosition02(void)
1342 {
1343   TestApplication application;
1344
1345   Actor actor = Actor::New();
1346
1347   // Set to random to start off with
1348   actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
1349
1350   Vector3 vector(100.0f, 100.0f, 100.0f);
1351
1352   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1353
1354   actor.SetPosition(vector.x, vector.y, vector.z);
1355
1356   // flush the queue and render once
1357   application.SendNotification();
1358   application.Render();
1359
1360   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1361   END_TEST;
1362 }
1363
1364 // SetPosition(Vector3 position)
1365 int UtcDaliActorSetPosition03(void)
1366 {
1367   TestApplication application;
1368
1369   Actor actor = Actor::New();
1370
1371   // Set to random to start off with
1372   actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
1373
1374   Vector3 vector(100.0f, 100.0f, 100.0f);
1375
1376   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1377
1378   actor.SetPosition(vector);
1379
1380   // flush the queue and render once
1381   application.SendNotification();
1382   application.Render();
1383
1384   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1385   END_TEST;
1386 }
1387
1388 int UtcDaliActorSetX(void)
1389 {
1390   TestApplication application;
1391
1392   Actor actor = Actor::New();
1393
1394   Vector3 vector(100.0f, 0.0f, 0.0f);
1395
1396   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1397
1398   actor.SetX(100.0f);
1399
1400   // flush the queue and render once
1401   application.SendNotification();
1402   application.Render();
1403
1404   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1405   END_TEST;
1406 }
1407
1408 int UtcDaliActorSetY(void)
1409 {
1410   TestApplication application;
1411
1412   Actor actor = Actor::New();
1413
1414   Vector3 vector(0.0f, 100.0f, 0.0f);
1415
1416   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1417
1418   actor.SetY(100.0f);
1419
1420   // flush the queue and render once
1421   application.SendNotification();
1422   application.Render();
1423
1424   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1425   END_TEST;
1426 }
1427
1428 int UtcDaliActorSetZ(void)
1429 {
1430   TestApplication application;
1431
1432   Actor actor = Actor::New();
1433
1434   Vector3 vector(0.0f, 0.0f, 100.0f);
1435
1436   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1437
1438   actor.SetZ(100.0f);
1439
1440   // flush the queue and render once
1441   application.SendNotification();
1442   application.Render();
1443
1444   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1445   END_TEST;
1446 }
1447
1448 int UtcDaliActorSetPositionProperties(void)
1449 {
1450   TestApplication application;
1451
1452   Actor actor = Actor::New();
1453
1454   Vector3 vector(0.7f, 0.8f, 0.9f);
1455   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1456
1457   actor.SetProperty( Actor::Property::POSITION_X, vector.x );
1458   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1459   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1460
1461   // flush the queue and render once
1462   application.SendNotification();
1463   application.Render();
1464
1465   DALI_TEST_EQUALS( vector.x, actor.GetCurrentPosition().x, TEST_LOCATION );
1466   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1467   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1468   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
1469   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
1470
1471   actor.SetProperty( Actor::Property::POSITION_Y, vector.y );
1472   DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1473   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1474
1475   // flush the queue and render once
1476   application.SendNotification();
1477   application.Render();
1478
1479   DALI_TEST_EQUALS( vector.y, actor.GetCurrentPosition().y, TEST_LOCATION );
1480   DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1481   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1482   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
1483   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
1484
1485   actor.SetProperty( Actor::Property::POSITION_Z, vector.z );
1486   DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1487   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1488
1489   // flush the queue and render once
1490   application.SendNotification();
1491   application.Render();
1492
1493   DALI_TEST_EQUALS( vector.z, actor.GetCurrentPosition().z, TEST_LOCATION );
1494   DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1495   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1496   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
1497   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
1498
1499   END_TEST;
1500 }
1501
1502 int UtcDaliActorTranslateBy(void)
1503 {
1504   TestApplication application;
1505
1506   Actor actor = Actor::New();
1507   Vector3 vector(100.0f, 100.0f, 100.0f);
1508
1509   DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
1510
1511   actor.SetPosition(vector);
1512
1513   // flush the queue and render once
1514   application.SendNotification();
1515   application.Render();
1516
1517   DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
1518
1519   actor.TranslateBy(vector);
1520
1521   // flush the queue and render once
1522   application.SendNotification();
1523   application.Render();
1524
1525   DALI_TEST_CHECK(vector*2.0f == actor.GetCurrentPosition());
1526   END_TEST;
1527 }
1528
1529 int UtcDaliActorGetCurrentPosition(void)
1530 {
1531   TestApplication application;
1532
1533   Actor actor = Actor::New();
1534   Vector3 setVector(100.0f, 100.0f, 0.0f);
1535   actor.SetPosition(setVector);
1536
1537   // flush the queue and render once
1538   application.SendNotification();
1539   application.Render();
1540
1541   DALI_TEST_CHECK(actor.GetCurrentPosition() == setVector);
1542   END_TEST;
1543 }
1544
1545 int UtcDaliActorGetCurrentWorldPosition(void)
1546 {
1547   TestApplication application;
1548
1549   Actor parent = Actor::New();
1550   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
1551   parent.SetPosition( parentPosition );
1552   parent.SetParentOrigin( ParentOrigin::CENTER );
1553   parent.SetAnchorPoint( AnchorPoint::CENTER );
1554   Stage::GetCurrent().Add( parent );
1555
1556   Actor child = Actor::New();
1557   child.SetParentOrigin( ParentOrigin::CENTER );
1558   child.SetAnchorPoint( AnchorPoint::CENTER );
1559   Vector3 childPosition( 6.0f, 6.0f, 6.0f );
1560   child.SetPosition( childPosition );
1561   parent.Add( child );
1562
1563   // The actors should not have a world position yet
1564   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1565   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1566
1567   application.SendNotification();
1568   application.Render(0);
1569
1570   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1571   DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
1572
1573   // The actors should have a world position now
1574   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1575   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
1576   END_TEST;
1577 }
1578
1579 int UtcDaliActorSetInheritPosition(void)
1580 {
1581   tet_infoline("Testing Actor::SetInheritPosition");
1582   TestApplication application;
1583
1584   Actor parent = Actor::New();
1585   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
1586   parent.SetPosition( parentPosition );
1587   parent.SetParentOrigin( ParentOrigin::CENTER );
1588   parent.SetAnchorPoint( AnchorPoint::CENTER );
1589   Stage::GetCurrent().Add( parent );
1590
1591   Actor child = Actor::New();
1592   child.SetParentOrigin( ParentOrigin::CENTER );
1593   child.SetAnchorPoint( AnchorPoint::CENTER );
1594   Vector3 childPosition( 10.0f, 11.0f, 12.0f );
1595   child.SetPosition( childPosition );
1596   parent.Add( child );
1597
1598   // The actors should not have a world position yet
1599   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1600   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
1601
1602   // first test default, which is to inherit position
1603   DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
1604   application.SendNotification();
1605   application.Render(0); // should only really call Update as Render is not required to update scene
1606   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1607   DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
1608   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1609   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
1610
1611   //Change child position
1612   Vector3 childOffset( -1.0f, 1.0f, 0.0f );
1613   child.SetPosition( childOffset );
1614
1615   // Use local position as world postion
1616   child.SetInheritPosition( false );
1617   DALI_TEST_EQUALS( child.IsPositionInherited(), false, TEST_LOCATION );
1618   application.SendNotification();
1619   application.Render(0); // should only really call Update as Render is not required to update scene
1620   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1621   DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
1622   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1623   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
1624
1625   //Change back to inherit position from parent
1626   child.SetInheritPosition( true );
1627   DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
1628   application.SendNotification();
1629   application.Render(0); // should only really call Update as Render is not required to update scene
1630   DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
1631   DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
1632   DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
1633   DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childOffset, TEST_LOCATION );
1634   END_TEST;
1635 }
1636
1637 int UtcDaliActorInheritOpacity(void)
1638 {
1639   tet_infoline("Testing Actor::Inherit Opacity");
1640   TestApplication application;
1641
1642   Actor parent = Actor::New();
1643   Actor child = Actor::New();
1644   parent.Add( child );
1645   Stage::GetCurrent().Add( parent );
1646
1647   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1648   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1649
1650   // flush the queue and render once
1651   application.SendNotification();
1652   application.Render();
1653
1654   parent.SetOpacity( 0.1f );
1655
1656   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
1657   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
1658
1659   application.SendNotification();
1660   application.Render();
1661
1662   DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1663   DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
1664   DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1665   DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1666   DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
1667   DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.f, 0.0001f, TEST_LOCATION );
1668
1669   END_TEST;
1670 }
1671
1672 // SetOrientation(float angleRadians, Vector3 axis)
1673 int UtcDaliActorSetOrientation01(void)
1674 {
1675   TestApplication application;
1676
1677   Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1678   Actor actor = Actor::New();
1679
1680   actor.SetOrientation(rotation);
1681
1682   // flush the queue and render once
1683   application.SendNotification();
1684   application.Render();
1685
1686   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1687   END_TEST;
1688 }
1689
1690 int UtcDaliActorSetOrientation02(void)
1691 {
1692   TestApplication application;
1693
1694   Actor actor = Actor::New();
1695
1696   Radian angle( 0.785f );
1697   Vector3 axis(1.0f, 1.0f, 0.0f);
1698
1699   actor.SetOrientation( angle, axis);
1700   Quaternion rotation( angle, axis );
1701   // flush the queue and render once
1702   application.SendNotification();
1703   application.Render();
1704   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1705
1706   Stage::GetCurrent().Add( actor );
1707   actor.RotateBy( Degree( 360 ), axis);
1708   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1709
1710   actor.SetOrientation( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
1711   Quaternion result( Radian( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
1712   // flush the queue and render once
1713   application.SendNotification();
1714   application.Render();
1715   DALI_TEST_EQUALS( result, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1716
1717   actor.SetOrientation( angle, axis);
1718   // flush the queue and render once
1719   application.SendNotification();
1720   application.Render();
1721   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1722
1723   Stage::GetCurrent().Remove( actor );
1724   END_TEST;
1725 }
1726
1727 // SetOrientation(float angleRadians, Vector3 axis)
1728 int UtcDaliActorSetOrientationProperty(void)
1729 {
1730   TestApplication application;
1731
1732   Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1733   Actor actor = Actor::New();
1734
1735   actor.SetProperty( Actor::Property::ORIENTATION, rotation );
1736   DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1737
1738   // flush the queue and render once
1739   application.SendNotification();
1740   application.Render();
1741
1742   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1743   DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1744   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
1745   END_TEST;
1746 }
1747
1748 // RotateBy(float angleRadians, Vector3 axis)
1749 int UtcDaliActorRotateBy01(void)
1750 {
1751   TestApplication application;
1752
1753   Actor actor = Actor::New();
1754
1755   Radian angle( M_PI * 0.25f );
1756   actor.RotateBy(( angle ), Vector3::ZAXIS);
1757   // flush the queue and render once
1758   application.SendNotification();
1759   application.Render();
1760   DALI_TEST_EQUALS(Quaternion( angle, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1761
1762   Stage::GetCurrent().Add( actor );
1763
1764   actor.RotateBy( angle, Vector3::ZAXIS);
1765   // flush the queue and render once
1766   application.SendNotification();
1767   application.Render();
1768   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1769
1770   Stage::GetCurrent().Remove( actor );
1771   END_TEST;
1772 }
1773
1774 // RotateBy(Quaternion relativeRotation)
1775 int UtcDaliActorRotateBy02(void)
1776 {
1777   TestApplication application;
1778
1779   Actor actor = Actor::New();
1780
1781   Radian angle( M_PI * 0.25f );
1782   Quaternion rotation(angle, Vector3::ZAXIS);
1783   actor.RotateBy(rotation);
1784   // flush the queue and render once
1785   application.SendNotification();
1786   application.Render();
1787   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1788
1789   actor.RotateBy(rotation);
1790   // flush the queue and render once
1791   application.SendNotification();
1792   application.Render();
1793   DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1794   END_TEST;
1795 }
1796
1797 int UtcDaliActorGetCurrentOrientation(void)
1798 {
1799   TestApplication application;
1800   Actor actor = Actor::New();
1801
1802   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
1803   actor.SetOrientation(rotation);
1804   // flush the queue and render once
1805   application.SendNotification();
1806   application.Render();
1807   DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
1808   END_TEST;
1809 }
1810
1811 int UtcDaliActorGetCurrentWorldOrientation(void)
1812 {
1813   tet_infoline("Testing Actor::GetCurrentWorldRotation");
1814   TestApplication application;
1815
1816   Actor parent = Actor::New();
1817   Radian rotationAngle( Degree(90.0f) );
1818   Quaternion rotation( rotationAngle, Vector3::YAXIS );
1819   parent.SetOrientation( rotation );
1820   Stage::GetCurrent().Add( parent );
1821
1822   Actor child = Actor::New();
1823   child.SetOrientation( rotation );
1824   parent.Add( child );
1825
1826   // The actors should not have a world rotation yet
1827   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
1828   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
1829
1830   application.SendNotification();
1831   application.Render(0);
1832
1833   DALI_TEST_EQUALS( parent.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
1834   DALI_TEST_EQUALS( child.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
1835
1836   // The actors should have a world rotation now
1837   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1838   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1839
1840   // turn off child rotation inheritance
1841   child.SetInheritOrientation( false );
1842   DALI_TEST_EQUALS( child.IsOrientationInherited(), false, TEST_LOCATION );
1843   application.SendNotification();
1844   application.Render(0);
1845
1846   // The actors should have a world rotation now
1847   DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
1848   DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), rotation, 0.001, TEST_LOCATION );
1849   END_TEST;
1850 }
1851
1852 // SetScale(float scale)
1853 int UtcDaliActorSetScale01(void)
1854 {
1855   TestApplication application;
1856
1857   Actor actor = Actor::New();
1858
1859   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1860   actor.SetScale(0.25f);
1861
1862   Vector3 scale(10.0f, 10.0f, 10.0f);
1863   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1864
1865   actor.SetScale(scale.x);
1866
1867   // flush the queue and render once
1868   application.SendNotification();
1869   application.Render();
1870
1871   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1872   END_TEST;
1873 }
1874
1875 // SetScale(float scaleX, float scaleY, float scaleZ)
1876 int UtcDaliActorSetScale02(void)
1877 {
1878   TestApplication application;
1879   Vector3 scale(10.0f, 10.0f, 10.0f);
1880
1881   Actor actor = Actor::New();
1882
1883   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1884   actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
1885
1886   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1887
1888   actor.SetScale(scale.x, scale.y, scale.z);
1889   // flush the queue and render once
1890   application.SendNotification();
1891   application.Render();
1892   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1893
1894   // add to stage and test
1895   Stage::GetCurrent().Add( actor );
1896   actor.SetScale( 2.0f, 2.0f, 2.0f );
1897   // flush the queue and render once
1898   application.SendNotification();
1899   application.Render();
1900   DALI_TEST_EQUALS( Vector3( 2.0f, 2.0f, 2.0f ), actor.GetCurrentScale(), 0.001, TEST_LOCATION);
1901
1902   Stage::GetCurrent().Remove( actor );
1903
1904   END_TEST;
1905 }
1906
1907 // SetScale(Vector3 scale)
1908 int UtcDaliActorSetScale03(void)
1909 {
1910   TestApplication application;
1911   Vector3 scale(10.0f, 10.0f, 10.0f);
1912
1913   Actor actor = Actor::New();
1914
1915   // Set to random value first - GetCurrentScale() asserts if called before SetScale()
1916   actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
1917
1918   DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
1919
1920   actor.SetScale(scale);
1921
1922   // flush the queue and render once
1923   application.SendNotification();
1924   application.Render();
1925
1926   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
1927   END_TEST;
1928 }
1929
1930 int UtcDaliActorSetScaleIndividual(void)
1931 {
1932   TestApplication application;
1933
1934   Actor actor = Actor::New();
1935
1936   Vector3 vector(0.7f, 0.8f, 0.9f);
1937   DALI_TEST_CHECK(vector != actor.GetCurrentScale());
1938
1939   actor.SetProperty( Actor::Property::SCALE_X, vector.x );
1940   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1941
1942   // flush the queue and render once
1943   application.SendNotification();
1944   application.Render();
1945
1946   DALI_TEST_EQUALS( vector.x, actor.GetCurrentScale().x, TEST_LOCATION );
1947   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1948   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
1949
1950   actor.SetProperty( Actor::Property::SCALE_Y, vector.y );
1951   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1952
1953   // flush the queue and render once
1954   application.SendNotification();
1955   application.Render();
1956
1957   DALI_TEST_EQUALS( vector.y, actor.GetCurrentScale().y, TEST_LOCATION );
1958   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1959   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
1960
1961   actor.SetProperty( Actor::Property::SCALE_Z, vector.z );
1962   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1963
1964   // flush the queue and render once
1965   application.SendNotification();
1966   application.Render();
1967
1968   DALI_TEST_EQUALS( vector.z, actor.GetCurrentScale().z, TEST_LOCATION );
1969   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1970   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
1971
1972   DALI_TEST_EQUALS( vector, actor.GetProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
1973   DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
1974
1975   END_TEST;
1976 }
1977
1978 int UtcDaliActorScaleBy(void)
1979 {
1980   TestApplication application;
1981   Actor actor = Actor::New();
1982   Vector3 vector(100.0f, 100.0f, 100.0f);
1983
1984   DALI_TEST_CHECK(vector != actor.GetCurrentScale());
1985
1986   actor.SetScale(vector);
1987
1988   // flush the queue and render once
1989   application.SendNotification();
1990   application.Render();
1991
1992   DALI_TEST_CHECK(vector == actor.GetCurrentScale());
1993
1994   actor.ScaleBy(vector);
1995
1996   // flush the queue and render once
1997   application.SendNotification();
1998   application.Render();
1999
2000   DALI_TEST_CHECK(vector*100.0f == actor.GetCurrentScale());
2001   END_TEST;
2002 }
2003
2004 int UtcDaliActorGetCurrentScale(void)
2005 {
2006   TestApplication application;
2007   Vector3 scale(12.0f, 1.0f, 2.0f);
2008
2009   Actor actor = Actor::New();
2010
2011   actor.SetScale(scale);
2012
2013   // flush the queue and render once
2014   application.SendNotification();
2015   application.Render();
2016
2017   DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
2018   END_TEST;
2019 }
2020
2021 int UtcDaliActorGetCurrentWorldScale(void)
2022 {
2023   TestApplication application;
2024
2025   Actor parent = Actor::New();
2026   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2027   parent.SetScale( parentScale );
2028   Stage::GetCurrent().Add( parent );
2029
2030   Actor child = Actor::New();
2031   Vector3 childScale( 2.0f, 2.0f, 2.0f );
2032   child.SetScale( childScale );
2033   parent.Add( child );
2034
2035   // The actors should not have a scale yet
2036   DALI_TEST_EQUALS( parent.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
2037   DALI_TEST_EQUALS( child.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
2038
2039   // The actors should not have a world scale yet
2040   DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
2041   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
2042
2043   application.SendNotification();
2044   application.Render(0);
2045
2046   DALI_TEST_EQUALS( parent.GetCurrentScale(), parentScale, TEST_LOCATION );
2047   DALI_TEST_EQUALS( child.GetCurrentScale(), childScale, TEST_LOCATION );
2048
2049   // The actors should have a world scale now
2050   DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), parentScale, TEST_LOCATION );
2051   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
2052   END_TEST;
2053 }
2054
2055 int UtcDaliActorInheritScale(void)
2056 {
2057   tet_infoline("Testing Actor::SetInheritScale");
2058   TestApplication application;
2059
2060   Actor parent = Actor::New();
2061   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2062   parent.SetScale( parentScale );
2063   Stage::GetCurrent().Add( parent );
2064
2065   Actor child = Actor::New();
2066   Vector3 childScale( 2.0f, 2.0f, 2.0f );
2067   child.SetScale( childScale );
2068   parent.Add( child );
2069
2070   application.SendNotification();
2071   application.Render(0);
2072
2073   DALI_TEST_EQUALS( child.IsScaleInherited(), true, TEST_LOCATION );
2074   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
2075
2076   child.SetInheritScale( false );
2077   DALI_TEST_EQUALS( child.IsScaleInherited(), false, TEST_LOCATION );
2078
2079   application.SendNotification();
2080   application.Render(0);
2081
2082   DALI_TEST_EQUALS( child.GetCurrentWorldScale(), childScale, TEST_LOCATION );
2083   END_TEST;
2084 }
2085
2086 int UtcDaliActorSetVisible(void)
2087 {
2088   TestApplication application;
2089
2090   Actor actor = Actor::New();
2091   actor.SetVisible(false);
2092   // flush the queue and render once
2093   application.SendNotification();
2094   application.Render();
2095   DALI_TEST_CHECK(actor.IsVisible() == false);
2096
2097   actor.SetVisible(true);
2098   // flush the queue and render once
2099   application.SendNotification();
2100   application.Render();
2101   DALI_TEST_CHECK(actor.IsVisible() == true);
2102
2103   // put actor on stage
2104   Stage::GetCurrent().Add( actor );
2105   actor.SetVisible(false);
2106   // flush the queue and render once
2107   application.SendNotification();
2108   application.Render();
2109   DALI_TEST_CHECK(actor.IsVisible() == false);
2110   END_TEST;
2111 }
2112
2113 int UtcDaliActorIsVisible(void)
2114 {
2115   TestApplication application;
2116
2117   Actor actor = Actor::New();
2118
2119   DALI_TEST_CHECK(actor.IsVisible() == true);
2120   END_TEST;
2121 }
2122
2123 int UtcDaliActorSetOpacity(void)
2124 {
2125   TestApplication application;
2126
2127   Actor actor = Actor::New();
2128   // initial opacity is 1
2129   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 1.0f, TEST_LOCATION );
2130
2131   actor.SetOpacity( 0.4f);
2132   // flush the queue and render once
2133   application.SendNotification();
2134   application.Render();
2135   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.4f, TEST_LOCATION );
2136
2137   // change opacity, actor is on stage to change is not immediate
2138   actor.SetOpacity( actor.GetCurrentOpacity() + 0.1f );
2139   // flush the queue and render once
2140   application.SendNotification();
2141   application.Render();
2142   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
2143
2144   // put actor on stage
2145   Stage::GetCurrent().Add( actor );
2146
2147   // change opacity, actor is on stage to change is not immediate
2148   actor.SetOpacity( 0.9f );
2149   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
2150   // flush the queue and render once
2151   application.SendNotification();
2152   application.Render();
2153   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.9f, TEST_LOCATION );
2154
2155   // change opacity, actor is on stage to change is not immediate
2156   actor.SetOpacity( actor.GetCurrentOpacity() - 0.9f );
2157   // flush the queue and render once
2158   application.SendNotification();
2159   application.Render();
2160   DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.0f, TEST_LOCATION );
2161   END_TEST;
2162 }
2163
2164 int UtcDaliActorGetCurrentOpacity(void)
2165 {
2166   TestApplication application;
2167
2168   Actor actor = Actor::New();
2169   DALI_TEST_CHECK(actor.GetCurrentOpacity() != 0.5f);
2170
2171   actor.SetOpacity(0.5f);
2172   // flush the queue and render once
2173   application.SendNotification();
2174   application.Render();
2175   DALI_TEST_CHECK(actor.GetCurrentOpacity() == 0.5f);
2176   END_TEST;
2177 }
2178
2179 int UtcDaliActorSetSensitive(void)
2180 {
2181   TestApplication application;
2182   Actor actor = Actor::New();
2183
2184   bool sensitive = !actor.IsSensitive();
2185
2186   actor.SetSensitive(sensitive);
2187
2188   DALI_TEST_CHECK(sensitive == actor.IsSensitive());
2189   END_TEST;
2190 }
2191
2192 int UtcDaliActorIsSensitive(void)
2193 {
2194   TestApplication application;
2195   Actor actor = Actor::New();
2196   actor.SetSensitive(false);
2197
2198   DALI_TEST_CHECK(false == actor.IsSensitive());
2199   END_TEST;
2200 }
2201
2202 int UtcDaliActorSetColor(void)
2203 {
2204   TestApplication application;
2205   Actor actor = Actor::New();
2206   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
2207
2208   DALI_TEST_CHECK(color != actor.GetCurrentColor());
2209
2210   actor.SetColor(color);
2211   // flush the queue and render once
2212   application.SendNotification();
2213   application.Render();
2214   DALI_TEST_CHECK(color == actor.GetCurrentColor());
2215
2216   actor.SetColor( actor.GetCurrentColor() + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
2217   // flush the queue and render once
2218   application.SendNotification();
2219   application.Render();
2220   DALI_TEST_EQUALS( Vector4( 0.6f, 0.5f, 0.4f, 0.1f ), actor.GetCurrentColor(),  TEST_LOCATION );
2221
2222   Stage::GetCurrent().Add( actor );
2223   actor.SetColor( color );
2224   // flush the queue and render once
2225   application.SendNotification();
2226   application.Render();
2227   DALI_TEST_EQUALS( color, actor.GetCurrentColor(),  TEST_LOCATION );
2228
2229   actor.SetColor( actor.GetCurrentColor() + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
2230   // flush the queue and render once
2231   application.SendNotification();
2232   application.Render();
2233   // Actor color is not clamped
2234   DALI_TEST_EQUALS( Vector4( 2.1f, 2.1f, 2.1f, 1.6f ), actor.GetCurrentColor(),  TEST_LOCATION );
2235   // world color is clamped
2236   DALI_TEST_EQUALS( Vector4( 1.0f, 1.0f, 1.0f, 1.0f ), actor.GetCurrentWorldColor(),  TEST_LOCATION );
2237
2238   actor.SetProperty( Actor::Property::COLOR, color );
2239   DALI_TEST_EQUALS( color, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2240
2241   Vector3 newColor( 1.0f, 0.0f, 0.0f );
2242   actor.SetProperty( Actor::Property::COLOR, newColor );
2243   DALI_TEST_EQUALS( Vector4( newColor.r, newColor.g, newColor.b, 1.0f ), actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2244
2245   Stage::GetCurrent().Remove( actor );
2246   END_TEST;
2247 }
2248
2249 int UtcDaliActorSetColorIndividual(void)
2250 {
2251   TestApplication application;
2252
2253   Actor actor = Actor::New();
2254
2255   Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
2256   DALI_TEST_CHECK(vector != actor.GetCurrentColor());
2257
2258   actor.SetProperty( Actor::Property::COLOR_RED, vector.r );
2259   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2260
2261   // flush the queue and render once
2262   application.SendNotification();
2263   application.Render();
2264
2265   DALI_TEST_EQUALS( vector.r, actor.GetCurrentColor().r, TEST_LOCATION );
2266   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2267   DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
2268
2269   actor.SetProperty( Actor::Property::COLOR_GREEN, vector.g );
2270   DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2271
2272   // flush the queue and render once
2273   application.SendNotification();
2274   application.Render();
2275
2276   DALI_TEST_EQUALS( vector.g, actor.GetCurrentColor().g, TEST_LOCATION );
2277   DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2278   DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
2279
2280   actor.SetProperty( Actor::Property::COLOR_BLUE, vector.b );
2281   DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2282
2283   // flush the queue and render once
2284   application.SendNotification();
2285   application.Render();
2286
2287   DALI_TEST_EQUALS( vector.b, actor.GetCurrentColor().b, TEST_LOCATION );
2288   DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2289   DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
2290
2291
2292   actor.SetProperty( Actor::Property::COLOR_ALPHA, vector.a );
2293   DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2294
2295   // flush the queue and render once
2296   application.SendNotification();
2297   application.Render();
2298
2299   DALI_TEST_EQUALS( vector.a, actor.GetCurrentColor().a, TEST_LOCATION );
2300   DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2301   DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
2302
2303   DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2304   DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
2305
2306   actor.SetProperty( DevelActor::Property::OPACITY, 0.2f );
2307
2308
2309   // flush the queue and render once
2310   application.SendNotification();
2311   application.Render();
2312
2313   DALI_TEST_EQUALS( 0.2f, actor.GetCurrentColor().a, TEST_LOCATION );
2314
2315   END_TEST;
2316 }
2317
2318
2319 int UtcDaliActorGetCurrentColor(void)
2320 {
2321   TestApplication application;
2322   Actor actor = Actor::New();
2323   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
2324
2325   actor.SetColor(color);
2326   // flush the queue and render once
2327   application.SendNotification();
2328   application.Render();
2329   DALI_TEST_CHECK(color == actor.GetCurrentColor());
2330   END_TEST;
2331 }
2332
2333 int UtcDaliActorGetCurrentWorldColor(void)
2334 {
2335   tet_infoline("Actor::GetCurrentWorldColor");
2336   TestApplication application;
2337
2338   Actor parent = Actor::New();
2339   Vector4 parentColor( 1.0f, 0.5f, 0.0f, 0.8f );
2340   parent.SetColor( parentColor );
2341   Stage::GetCurrent().Add( parent );
2342
2343   Actor child = Actor::New();
2344   Vector4 childColor( 0.5f, 0.6f, 0.5f, 1.0f );
2345   child.SetColor( childColor );
2346   parent.Add( child );
2347
2348   DALI_TEST_EQUALS( parent.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
2349   DALI_TEST_EQUALS( child.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
2350
2351   // verify the default color mode
2352   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetColorMode(), TEST_LOCATION );
2353
2354   // The actors should not have a world color yet
2355   DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
2356   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
2357
2358   application.SendNotification();
2359   application.Render(0);
2360
2361   DALI_TEST_EQUALS( parent.GetCurrentColor(), parentColor, TEST_LOCATION );
2362   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2363
2364   // The actors should have a world color now
2365   DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
2366   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Vector4( childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION );
2367
2368   // use own color
2369   child.SetColorMode( USE_OWN_COLOR );
2370   application.SendNotification();
2371   application.Render(0);
2372   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), childColor, TEST_LOCATION );
2373
2374   // use parent color
2375   child.SetColorMode( USE_PARENT_COLOR );
2376   application.SendNotification();
2377   application.Render(0);
2378   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2379   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
2380
2381   // use parent alpha
2382   child.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
2383   application.SendNotification();
2384   application.Render(0);
2385   Vector4 expectedColor( childColor );
2386   expectedColor.a *= parentColor.a;
2387   DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
2388   DALI_TEST_EQUALS( child.GetCurrentWorldColor(), expectedColor, TEST_LOCATION );
2389   END_TEST;
2390 }
2391
2392 int UtcDaliActorSetColorMode(void)
2393 {
2394   tet_infoline("Actor::SetColorMode");
2395   TestApplication application;
2396   Actor actor = Actor::New();
2397   Actor child = Actor::New();
2398   actor.Add( child );
2399
2400   actor.SetColorMode( USE_OWN_COLOR );
2401   DALI_TEST_EQUALS( USE_OWN_COLOR, actor.GetColorMode(), TEST_LOCATION );
2402
2403   actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
2404   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
2405
2406   actor.SetColorMode( USE_PARENT_COLOR );
2407   DALI_TEST_EQUALS( USE_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
2408
2409   actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
2410   DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetColorMode(), TEST_LOCATION );
2411   END_TEST;
2412 }
2413
2414 int UtcDaliActorScreenToLocal(void)
2415 {
2416   TestApplication application;
2417   Actor actor = Actor::New();
2418   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2419   actor.SetSize(100.0f, 100.0f);
2420   actor.SetPosition(10.0f, 10.0f);
2421   Stage::GetCurrent().Add(actor);
2422
2423   // flush the queue and render once
2424   application.SendNotification();
2425   application.Render();
2426
2427   float localX;
2428   float localY;
2429
2430   application.SendNotification();
2431   application.Render();
2432
2433   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, 50.0f, 50.0f) );
2434
2435   DALI_TEST_EQUALS(localX, 40.0f, 0.01f, TEST_LOCATION);
2436   DALI_TEST_EQUALS(localY, 40.0f, 0.01f, TEST_LOCATION);
2437   END_TEST;
2438 }
2439
2440 int UtcDaliActorSetLeaveRequired(void)
2441 {
2442   TestApplication application;
2443
2444   Actor actor = Actor::New();
2445
2446   actor.SetLeaveRequired(false);
2447   DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
2448
2449   actor.SetLeaveRequired(true);
2450   DALI_TEST_CHECK(actor.GetLeaveRequired() == true);
2451   END_TEST;
2452 }
2453
2454 int UtcDaliActorGetLeaveRequired(void)
2455 {
2456   TestApplication application;
2457
2458   Actor actor = Actor::New();
2459
2460   DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
2461   END_TEST;
2462 }
2463
2464 int UtcDaliActorSetKeyboardFocusable(void)
2465 {
2466   TestApplication application;
2467
2468   Actor actor = Actor::New();
2469
2470   actor.SetKeyboardFocusable(true);
2471   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == true);
2472
2473   actor.SetKeyboardFocusable(false);
2474   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
2475   END_TEST;
2476 }
2477
2478 int UtcDaliActorIsKeyboardFocusable(void)
2479 {
2480   TestApplication application;
2481
2482   Actor actor = Actor::New();
2483
2484   DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
2485   END_TEST;
2486 }
2487
2488 int UtcDaliActorRemoveConstraints(void)
2489 {
2490   tet_infoline(" UtcDaliActorRemoveConstraints");
2491   TestApplication application;
2492
2493   gTestConstraintCalled = false;
2494
2495   Actor actor = Actor::New();
2496
2497   Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraint() );
2498   constraint.Apply();
2499   actor.RemoveConstraints();
2500
2501   DALI_TEST_CHECK( gTestConstraintCalled == false );
2502
2503   Stage::GetCurrent().Add( actor );
2504   constraint.Apply();
2505
2506   // flush the queue and render once
2507   application.SendNotification();
2508   application.Render();
2509
2510   actor.RemoveConstraints();
2511
2512   DALI_TEST_CHECK( gTestConstraintCalled == true );
2513   END_TEST;
2514 }
2515
2516 int UtcDaliActorRemoveConstraintTag(void)
2517 {
2518   tet_infoline(" UtcDaliActorRemoveConstraintTag");
2519   TestApplication application;
2520
2521   Actor actor = Actor::New();
2522
2523   // 1. Apply Constraint1 and Constraint2, and test...
2524   unsigned int result1 = 0u;
2525   unsigned int result2 = 0u;
2526
2527   unsigned constraint1Tag = 1u;
2528   Constraint constraint1 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) );
2529   constraint1.SetTag( constraint1Tag );
2530   constraint1.Apply();
2531
2532   unsigned constraint2Tag = 2u;
2533   Constraint constraint2 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2) );
2534   constraint2.SetTag( constraint2Tag );
2535   constraint2.Apply();
2536
2537   Stage::GetCurrent().Add( actor );
2538   // flush the queue and render once
2539   application.SendNotification();
2540   application.Render();
2541
2542   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2543   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2544
2545   // 2. Remove Constraint1 and test...
2546   result1 = 0;
2547   result2 = 0;
2548   actor.RemoveConstraints(constraint1Tag);
2549   // make color property dirty, which will trigger constraints to be reapplied.
2550   actor.SetColor( Color::WHITE );
2551   // flush the queue and render once
2552   application.SendNotification();
2553   application.Render();
2554
2555   DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION );  ///< constraint 1 should not apply now.
2556   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2557
2558   // 3. Re-Apply Constraint1 and test...
2559   result1 = 0;
2560   result2 = 0;
2561   constraint1.Apply();
2562   // make color property dirty, which will trigger constraints to be reapplied.
2563   actor.SetColor( Color::WHITE );
2564   // flush the queue and render once
2565   application.SendNotification();
2566   application.Render();
2567
2568   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2569   DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
2570
2571   // 2. Remove Constraint2 and test...
2572   result1 = 0;
2573   result2 = 0;
2574   actor.RemoveConstraints(constraint2Tag);
2575   // make color property dirty, which will trigger constraints to be reapplied.
2576   actor.SetColor( Color::WHITE );
2577   // flush the queue and render once
2578   application.SendNotification();
2579   application.Render();
2580
2581   DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
2582   DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
2583
2584   // 2. Remove Constraint1 as well and test...
2585   result1 = 0;
2586   result2 = 0;
2587   actor.RemoveConstraints(constraint1Tag);
2588   // make color property dirty, which will trigger constraints to be reapplied.
2589   actor.SetColor( Color::WHITE );
2590   // flush the queue and render once
2591   application.SendNotification();
2592   application.Render();
2593
2594   DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION ); ///< constraint 1 should not apply now.
2595   DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
2596   END_TEST;
2597 }
2598
2599 int UtcDaliActorTouchedSignal(void)
2600 {
2601   TestApplication application;
2602
2603   ResetTouchCallbacks();
2604
2605   // get the root layer
2606   Actor actor = Stage::GetCurrent().GetRootLayer();
2607   DALI_TEST_CHECK( gTouchCallBackCalled == false );
2608
2609   application.SendNotification();
2610   application.Render();
2611
2612   // connect to its touch signal
2613   actor.TouchedSignal().Connect( TestCallback );
2614
2615   // simulate a touch event in the middle of the screen
2616   Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
2617   Dali::Integration::Point point;
2618   point.SetDeviceId( 1 );
2619   point.SetState( PointState::DOWN );
2620   point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
2621   Dali::Integration::TouchEvent touchEvent;
2622   touchEvent.AddPoint( point );
2623   application.ProcessEvent( touchEvent );
2624
2625   DALI_TEST_CHECK( gTouchCallBackCalled == true );
2626   END_TEST;
2627 }
2628
2629 int UtcDaliActorHoveredSignal(void)
2630 {
2631   TestApplication application;
2632
2633   gHoverCallBackCalled = false;
2634
2635   // get the root layer
2636   Actor actor = Stage::GetCurrent().GetRootLayer();
2637   DALI_TEST_CHECK( gHoverCallBackCalled == false );
2638
2639   application.SendNotification();
2640   application.Render();
2641
2642   // connect to its hover signal
2643   actor.HoveredSignal().Connect( TestCallback3 );
2644
2645   // simulate a hover event in the middle of the screen
2646   Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
2647   Dali::Integration::Point point;
2648   point.SetDeviceId( 1 );
2649   point.SetState( PointState::MOTION );
2650   point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
2651   Dali::Integration::HoverEvent hoverEvent;
2652   hoverEvent.AddPoint( point );
2653   application.ProcessEvent( hoverEvent );
2654
2655   DALI_TEST_CHECK( gHoverCallBackCalled == true );
2656   END_TEST;
2657 }
2658
2659 int UtcDaliActorOnOffStageSignal(void)
2660 {
2661   tet_infoline("Testing Dali::Actor::OnStageSignal() and OffStageSignal()");
2662
2663   TestApplication application;
2664
2665   // clean test data
2666   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2667   gActorNamesOnOffStage.clear();
2668
2669   Actor parent = Actor::New();
2670   parent.SetName( "parent" );
2671   parent.OnStageSignal().Connect( OnStageCallback );
2672   parent.OffStageSignal().Connect( OffStageCallback );
2673   // sanity check
2674   DALI_TEST_CHECK( gOnStageCallBackCalled == 0 );
2675   DALI_TEST_CHECK( gOffStageCallBackCalled == 0 );
2676
2677   // add parent to stage
2678   Stage::GetCurrent().Add( parent );
2679   // onstage emitted, offstage not
2680   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
2681   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2682   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2683
2684   // test adding a child, should get onstage emitted
2685   // clean test data
2686   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2687   gActorNamesOnOffStage.clear();
2688
2689   Actor child = Actor::New();
2690   child.SetName( "child" );
2691   child.OnStageSignal().Connect( OnStageCallback );
2692   child.OffStageSignal().Connect( OffStageCallback );
2693   parent.Add( child ); // add child
2694   // onstage emitted, offstage not
2695   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
2696   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2697   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2698
2699   // test removing parent from stage
2700   // clean test data
2701   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2702   gActorNamesOnOffStage.clear();
2703
2704   Stage::GetCurrent().Remove( parent );
2705   // onstage not emitted, offstage is
2706   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2707   DALI_TEST_EQUALS( gOffStageCallBackCalled, 2, TEST_LOCATION );
2708   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2709   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
2710
2711   // test adding parent back to stage
2712   // clean test data
2713   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2714   gActorNamesOnOffStage.clear();
2715
2716   Stage::GetCurrent().Add( parent );
2717   // onstage emitted, offstage not
2718   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 2, TEST_LOCATION );
2719   DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
2720   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2721   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
2722
2723   // test removing child
2724   // clean test data
2725   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2726   gActorNamesOnOffStage.clear();
2727
2728   parent.Remove( child );
2729   // onstage not emitted, offstage is
2730   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2731   DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
2732   DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2733
2734   // test removing parent
2735   // clean test data
2736   gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
2737   gActorNamesOnOffStage.clear();
2738
2739   Stage::GetCurrent().Remove( parent );
2740   // onstage not emitted, offstage is
2741   DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
2742   DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
2743   DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
2744   END_TEST;
2745 }
2746
2747 int UtcDaliActorFindChildByName(void)
2748 {
2749   tet_infoline("Testing Dali::Actor::FindChildByName()");
2750   TestApplication application;
2751
2752   Actor parent = Actor::New();
2753   parent.SetName( "parent" );
2754   Actor first  = Actor::New();
2755   first .SetName( "first" );
2756   Actor second = Actor::New();
2757   second.SetName( "second" );
2758
2759   parent.Add(first);
2760   first.Add(second);
2761
2762   Actor found = parent.FindChildByName( "foo" );
2763   DALI_TEST_CHECK( !found );
2764
2765   found = parent.FindChildByName( "parent" );
2766   DALI_TEST_CHECK( found == parent );
2767
2768   found = parent.FindChildByName( "first" );
2769   DALI_TEST_CHECK( found == first );
2770
2771   found = parent.FindChildByName( "second" );
2772   DALI_TEST_CHECK( found == second );
2773   END_TEST;
2774 }
2775
2776 int UtcDaliActorFindChildById(void)
2777 {
2778   tet_infoline("Testing Dali::Actor::UtcDaliActorFindChildById()");
2779   TestApplication application;
2780
2781   Actor parent = Actor::New();
2782   Actor first  = Actor::New();
2783   Actor second = Actor::New();
2784
2785   parent.Add(first);
2786   first.Add(second);
2787
2788   Actor found = parent.FindChildById( 100000 );
2789   DALI_TEST_CHECK( !found );
2790
2791   found = parent.FindChildById( parent.GetId() );
2792   DALI_TEST_CHECK( found == parent );
2793
2794   found = parent.FindChildById( first.GetId() );
2795   DALI_TEST_CHECK( found == first );
2796
2797   found = parent.FindChildById( second.GetId() );
2798   DALI_TEST_CHECK( found == second );
2799   END_TEST;
2800 }
2801
2802 int UtcDaliActorHitTest(void)
2803 {
2804   struct HitTestData
2805   {
2806   public:
2807     HitTestData( const Vector3& scale, const Vector2& touchPoint, bool result )
2808     : mScale( scale ),
2809       mTouchPoint( touchPoint ),
2810       mResult( result )
2811     {}
2812
2813     Vector3 mScale;
2814     Vector2 mTouchPoint;
2815     bool mResult;
2816   };
2817
2818   TestApplication application;
2819   tet_infoline(" UtcDaliActorHitTest");
2820
2821   // Fill a vector with different hit tests.
2822   struct HitTestData* hitTestData[] = {
2823     //                    scale                     touch point           result
2824     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 289.f, 400.f ), true ),  // touch point close to the right edge (inside)
2825     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), false ), // touch point close to the right edge (outside)
2826     new HitTestData( Vector3( 110.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), true ),  // same point as above with a wider scale. Should be inside.
2827     new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 200.f, 451.f ), false ), // touch point close to the down edge (outside)
2828     new HitTestData( Vector3( 100.f, 110.f, 1.f ), Vector2( 200.f, 451.f ), true ),  // same point as above with a wider scale. Should be inside.
2829     NULL,
2830   };
2831
2832   // get the root layer
2833   Actor actor = Actor::New();
2834   actor.SetAnchorPoint( AnchorPoint::CENTER );
2835   actor.SetParentOrigin( ParentOrigin::CENTER );
2836
2837   Stage::GetCurrent().Add( actor );
2838
2839   ResetTouchCallbacks();
2840
2841   unsigned int index = 0;
2842   while( NULL != hitTestData[index] )
2843   {
2844     actor.SetSize( 1.f, 1.f );
2845     actor.SetScale( hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z );
2846
2847     // flush the queue and render once
2848     application.SendNotification();
2849     application.Render();
2850
2851     DALI_TEST_CHECK( !gTouchCallBackCalled );
2852
2853     // connect to its touch signal
2854     actor.TouchedSignal().Connect(TestCallback);
2855
2856     Dali::Integration::Point point;
2857     point.SetState( PointState::DOWN );
2858     point.SetScreenPosition( Vector2( hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y ) );
2859     Dali::Integration::TouchEvent event;
2860     event.AddPoint( point );
2861
2862     // flush the queue and render once
2863     application.SendNotification();
2864     application.Render();
2865     application.ProcessEvent( event );
2866
2867     DALI_TEST_CHECK( gTouchCallBackCalled == hitTestData[index]->mResult );
2868
2869     if( gTouchCallBackCalled != hitTestData[index]->mResult )
2870       tet_printf("Test failed:\nScale %f %f %f\nTouchPoint %f, %f\nResult %d\n",
2871                  hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z,
2872                  hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y,
2873                  hitTestData[index]->mResult );
2874
2875     ResetTouchCallbacks();
2876     ++index;
2877   }
2878   END_TEST;
2879 }
2880
2881 int UtcDaliActorSetDrawMode(void)
2882 {
2883   TestApplication app;
2884   tet_infoline(" UtcDaliActorSetDrawModeOverlay");
2885
2886   Actor a = Actor::New();
2887
2888   Stage::GetCurrent().Add(a);
2889   app.SendNotification();
2890   app.Render(0);
2891   app.SendNotification();
2892   app.Render(1);
2893
2894   DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Ensure overlay is off by default
2895
2896   a.SetDrawMode( DrawMode::OVERLAY_2D );
2897   app.SendNotification();
2898   app.Render(1);
2899
2900   DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetDrawMode() ); // Check Actor is overlay
2901
2902   a.SetDrawMode( DrawMode::NORMAL );
2903   app.SendNotification();
2904   app.Render(1);
2905
2906   DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Check Actor is normal
2907   END_TEST;
2908 }
2909
2910 int UtcDaliActorSetDrawModeOverlayRender(void)
2911 {
2912   TestApplication app;
2913   tet_infoline(" UtcDaliActorSetDrawModeOverlayRender");
2914
2915   app.SendNotification();
2916   app.Render(1);
2917
2918   std::vector<GLuint> ids;
2919   ids.push_back( 8 );   // first rendered actor
2920   ids.push_back( 9 );   // second rendered actor
2921   ids.push_back( 10 );  // third rendered actor
2922   app.GetGlAbstraction().SetNextTextureIds( ids );
2923
2924   BufferImage imageA = BufferImage::New(16, 16);
2925   BufferImage imageB = BufferImage::New(16, 16);
2926   BufferImage imageC = BufferImage::New(16, 16);
2927   Actor a = CreateRenderableActor( imageA );
2928   Actor b = CreateRenderableActor( imageB );
2929   Actor c = CreateRenderableActor( imageC );
2930
2931   app.SendNotification();
2932   app.Render(1);
2933
2934   //Textures are bound when first created. Clear bound textures vector
2935   app.GetGlAbstraction().ClearBoundTextures();
2936
2937   // Render a,b,c as regular non-overlays. so order will be:
2938   // a (8)
2939   // b (9)
2940   // c (10)
2941   Stage::GetCurrent().Add(a);
2942   Stage::GetCurrent().Add(b);
2943   Stage::GetCurrent().Add(c);
2944
2945   app.SendNotification();
2946   app.Render(1);
2947
2948   // Should be 3 textures changes.
2949   const std::vector<GLuint>& boundTextures = app.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
2950   typedef std::vector<GLuint>::size_type TextureSize;
2951   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>( 3 ), TEST_LOCATION );
2952   if( boundTextures.size() == 3 )
2953   {
2954     DALI_TEST_CHECK( boundTextures[0] == 8u );
2955     DALI_TEST_CHECK( boundTextures[1] == 9u );
2956     DALI_TEST_CHECK( boundTextures[2] == 10u );
2957   }
2958
2959   // Now texture ids have been set, we can monitor their render order.
2960   // render a as an overlay (last), so order will be:
2961   // b (9)
2962   // c (10)
2963   // a (8)
2964   a.SetDrawMode( DrawMode::OVERLAY_2D );
2965   app.GetGlAbstraction().ClearBoundTextures();
2966
2967   app.SendNotification();
2968   app.Render(1);
2969
2970   // Should be 3 texture changes.
2971   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION );
2972   if( boundTextures.size() == 3 )
2973   {
2974     DALI_TEST_CHECK( boundTextures[0] == 9u );
2975     DALI_TEST_CHECK( boundTextures[1] == 10u );
2976     DALI_TEST_CHECK( boundTextures[2] == 8u );
2977   }
2978   END_TEST;
2979 }
2980
2981 int UtcDaliActorGetCurrentWorldMatrix(void)
2982 {
2983   TestApplication app;
2984   tet_infoline(" UtcDaliActorGetCurrentWorldMatrix");
2985
2986   Actor parent = Actor::New();
2987   parent.SetParentOrigin(ParentOrigin::CENTER);
2988   parent.SetAnchorPoint(AnchorPoint::CENTER);
2989   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
2990   Radian rotationAngle(Degree(85.0f));
2991   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
2992   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
2993   parent.SetPosition( parentPosition );
2994   parent.SetOrientation( parentRotation );
2995   parent.SetScale( parentScale );
2996   Stage::GetCurrent().Add( parent );
2997
2998   Actor child = Actor::New();
2999   child.SetParentOrigin(ParentOrigin::CENTER);
3000   Vector3 childPosition( 0.0f, 0.0f, 100.0f );
3001   Radian childRotationAngle(Degree(23.0f));
3002   Quaternion childRotation( childRotationAngle, Vector3::YAXIS );
3003   Vector3 childScale( 2.0f, 2.0f, 2.0f );
3004   child.SetPosition( childPosition );
3005   child.SetOrientation( childRotation );
3006   child.SetScale( childScale );
3007   parent.Add( child );
3008
3009   app.SendNotification();
3010   app.Render(0);
3011   app.Render();
3012   app.SendNotification();
3013
3014   Matrix parentMatrix(false);
3015   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3016
3017   Matrix childMatrix(false);
3018   childMatrix.SetTransformComponents( childScale, childRotation, childPosition );
3019
3020   //Child matrix should be the composition of child and parent
3021   Matrix childWorldMatrix(false);
3022   Matrix::Multiply( childWorldMatrix, childMatrix, parentMatrix);
3023
3024   DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
3025   DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), childWorldMatrix, 0.001, TEST_LOCATION );
3026   END_TEST;
3027 }
3028
3029
3030
3031 int UtcDaliActorConstrainedToWorldMatrix(void)
3032 {
3033   TestApplication app;
3034   tet_infoline(" UtcDaliActorConstrainedToWorldMatrix");
3035
3036   Actor parent = Actor::New();
3037   parent.SetParentOrigin(ParentOrigin::CENTER);
3038   parent.SetAnchorPoint(AnchorPoint::CENTER);
3039   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
3040   Radian rotationAngle(Degree(85.0f));
3041   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3042   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
3043   parent.SetPosition( parentPosition );
3044   parent.SetOrientation( parentRotation );
3045   parent.SetScale( parentScale );
3046   Stage::GetCurrent().Add( parent );
3047
3048   Actor child = Actor::New();
3049   child.SetParentOrigin(ParentOrigin::CENTER);
3050   Constraint posConstraint = Constraint::New<Vector3>( child, Actor::Property::POSITION, PositionComponentConstraint() );
3051   posConstraint.AddSource( Source( parent, Actor::Property::WORLD_MATRIX ) );
3052   posConstraint.Apply();
3053
3054   Stage::GetCurrent().Add( child );
3055
3056   app.SendNotification();
3057   app.Render(0);
3058   app.Render();
3059   app.SendNotification();
3060
3061   Matrix parentMatrix(false);
3062   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
3063
3064   DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
3065   DALI_TEST_EQUALS( child.GetCurrentPosition(), parent.GetCurrentPosition(), 0.001, TEST_LOCATION );
3066   END_TEST;
3067 }
3068
3069 int UtcDaliActorConstrainedToOrientation(void)
3070 {
3071   TestApplication app;
3072   tet_infoline(" UtcDaliActorConstrainedToOrientation");
3073
3074   Actor parent = Actor::New();
3075   parent.SetParentOrigin(ParentOrigin::CENTER);
3076   parent.SetAnchorPoint(AnchorPoint::CENTER);
3077   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
3078   Radian rotationAngle(Degree(85.0f));
3079   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
3080   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
3081   parent.SetPosition( parentPosition );
3082   parent.SetOrientation( parentRotation );
3083   parent.SetScale( parentScale );
3084   Stage::GetCurrent().Add( parent );
3085
3086   Actor child = Actor::New();
3087   child.SetParentOrigin(ParentOrigin::CENTER);
3088   Constraint posConstraint = Constraint::New<Quaternion>( child, Actor::Property::ORIENTATION, OrientationComponentConstraint() );
3089   posConstraint.AddSource( Source( parent, Actor::Property::ORIENTATION ) );
3090   posConstraint.Apply();
3091
3092   Stage::GetCurrent().Add( child );
3093
3094   app.SendNotification();
3095   app.Render(0);
3096   app.Render();
3097   app.SendNotification();
3098
3099   DALI_TEST_EQUALS( child.GetCurrentOrientation(), parent.GetCurrentOrientation(), 0.001, TEST_LOCATION );
3100   END_TEST;
3101 }
3102
3103 int UtcDaliActorConstrainedToOpacity(void)
3104 {
3105   TestApplication app;
3106   tet_infoline(" UtcDaliActorConstrainedToOpacity");
3107
3108   Actor parent = Actor::New();
3109   parent.SetOpacity( 0.7f );
3110   Stage::GetCurrent().Add( parent );
3111
3112   Actor child = Actor::New();
3113   Constraint opacityConstraint = Constraint::New<float>( child, DevelActor::Property::OPACITY, EqualToConstraint() );
3114   opacityConstraint.AddSource( Source( parent, DevelActor::Property::OPACITY ) );
3115   opacityConstraint.Apply();
3116
3117   Stage::GetCurrent().Add( child );
3118
3119   app.SendNotification();
3120   app.Render(0);
3121   app.Render();
3122   app.SendNotification();
3123
3124   DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
3125
3126   parent.SetOpacity( 0.3f );
3127
3128   app.SendNotification();
3129   app.Render(0);
3130   app.Render();
3131   app.SendNotification();
3132
3133   DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
3134
3135   END_TEST;
3136 }
3137
3138 int UtcDaliActorUnparent(void)
3139 {
3140   TestApplication app;
3141   tet_infoline(" UtcDaliActorUnparent");
3142
3143   Actor parent = Actor::New();
3144   Stage::GetCurrent().Add( parent );
3145
3146   Actor child = Actor::New();
3147
3148   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3149   DALI_TEST_CHECK( !child.GetParent() );
3150
3151   // Test that calling Unparent with no parent is a NOOP
3152   child.Unparent();
3153
3154   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3155   DALI_TEST_CHECK( !child.GetParent() );
3156
3157   // Test that Unparent works
3158   parent.Add( child );
3159
3160   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
3161   DALI_TEST_CHECK( parent == child.GetParent() );
3162
3163   child.Unparent();
3164
3165   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3166   DALI_TEST_CHECK( !child.GetParent() );
3167
3168   // Test that UnparentAndReset works
3169   parent.Add( child );
3170
3171   DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
3172   DALI_TEST_CHECK( parent == child.GetParent() );
3173
3174   UnparentAndReset( child );
3175
3176   DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
3177   DALI_TEST_CHECK( !child );
3178
3179   // Test that UnparentAndReset is a NOOP with empty handle
3180   UnparentAndReset( child );
3181
3182   DALI_TEST_CHECK( !child );
3183   END_TEST;
3184 }
3185
3186 int UtcDaliActorGetChildAt(void)
3187 {
3188   TestApplication app;
3189   tet_infoline(" UtcDaliActorGetChildAt");
3190
3191   Actor parent = Actor::New();
3192   Stage::GetCurrent().Add( parent );
3193
3194   Actor child0 = Actor::New();
3195   parent.Add( child0 );
3196
3197   Actor child1 = Actor::New();
3198   parent.Add( child1 );
3199
3200   Actor child2 = Actor::New();
3201   parent.Add( child2 );
3202
3203   DALI_TEST_EQUALS( parent.GetChildAt( 0 ), child0, TEST_LOCATION );
3204   DALI_TEST_EQUALS( parent.GetChildAt( 1 ), child1, TEST_LOCATION );
3205   DALI_TEST_EQUALS( parent.GetChildAt( 2 ), child2, TEST_LOCATION );
3206   END_TEST;
3207 }
3208
3209 int UtcDaliActorSetGetOverlay(void)
3210 {
3211   TestApplication app;
3212   tet_infoline(" UtcDaliActorSetGetOverlay");
3213
3214   Actor parent = Actor::New();
3215   parent.SetDrawMode(DrawMode::OVERLAY_2D );
3216   DALI_TEST_CHECK( parent.GetDrawMode() == DrawMode::OVERLAY_2D );
3217   END_TEST;
3218 }
3219
3220
3221 int UtcDaliActorCreateDestroy(void)
3222 {
3223   Actor* actor = new Actor;
3224   DALI_TEST_CHECK( actor );
3225   delete actor;
3226   END_TEST;
3227 }
3228
3229 namespace
3230 {
3231 struct PropertyStringIndex
3232 {
3233   const char * const name;
3234   const Property::Index index;
3235   const Property::Type type;
3236 };
3237
3238 const PropertyStringIndex PROPERTY_TABLE[] =
3239 {
3240   { "parentOrigin",             Actor::Property::PARENT_ORIGIN,            Property::VECTOR3     },
3241   { "parentOriginX",            Actor::Property::PARENT_ORIGIN_X,          Property::FLOAT       },
3242   { "parentOriginY",            Actor::Property::PARENT_ORIGIN_Y,          Property::FLOAT       },
3243   { "parentOriginZ",            Actor::Property::PARENT_ORIGIN_Z,          Property::FLOAT       },
3244   { "anchorPoint",              Actor::Property::ANCHOR_POINT,             Property::VECTOR3     },
3245   { "anchorPointX",             Actor::Property::ANCHOR_POINT_X,           Property::FLOAT       },
3246   { "anchorPointY",             Actor::Property::ANCHOR_POINT_Y,           Property::FLOAT       },
3247   { "anchorPointZ",             Actor::Property::ANCHOR_POINT_Z,           Property::FLOAT       },
3248   { "size",                     Actor::Property::SIZE,                     Property::VECTOR3     },
3249   { "sizeWidth",                Actor::Property::SIZE_WIDTH,               Property::FLOAT       },
3250   { "sizeHeight",               Actor::Property::SIZE_HEIGHT,              Property::FLOAT       },
3251   { "sizeDepth",                Actor::Property::SIZE_DEPTH,               Property::FLOAT       },
3252   { "position",                 Actor::Property::POSITION,                 Property::VECTOR3     },
3253   { "positionX",                Actor::Property::POSITION_X,               Property::FLOAT       },
3254   { "positionY",                Actor::Property::POSITION_Y,               Property::FLOAT       },
3255   { "positionZ",                Actor::Property::POSITION_Z,               Property::FLOAT       },
3256   { "worldPosition",            Actor::Property::WORLD_POSITION,           Property::VECTOR3     },
3257   { "worldPositionX",           Actor::Property::WORLD_POSITION_X,         Property::FLOAT       },
3258   { "worldPositionY",           Actor::Property::WORLD_POSITION_Y,         Property::FLOAT       },
3259   { "worldPositionZ",           Actor::Property::WORLD_POSITION_Z,         Property::FLOAT       },
3260   { "orientation",              Actor::Property::ORIENTATION,              Property::ROTATION    },
3261   { "worldOrientation",         Actor::Property::WORLD_ORIENTATION,        Property::ROTATION    },
3262   { "scale",                    Actor::Property::SCALE,                    Property::VECTOR3     },
3263   { "scaleX",                   Actor::Property::SCALE_X,                  Property::FLOAT       },
3264   { "scaleY",                   Actor::Property::SCALE_Y,                  Property::FLOAT       },
3265   { "scaleZ",                   Actor::Property::SCALE_Z,                  Property::FLOAT       },
3266   { "worldScale",               Actor::Property::WORLD_SCALE,              Property::VECTOR3     },
3267   { "visible",                  Actor::Property::VISIBLE,                  Property::BOOLEAN     },
3268   { "color",                    Actor::Property::COLOR,                    Property::VECTOR4     },
3269   { "colorRed",                 Actor::Property::COLOR_RED,                Property::FLOAT       },
3270   { "colorGreen",               Actor::Property::COLOR_GREEN,              Property::FLOAT       },
3271   { "colorBlue",                Actor::Property::COLOR_BLUE,               Property::FLOAT       },
3272   { "colorAlpha",               Actor::Property::COLOR_ALPHA,              Property::FLOAT       },
3273   { "worldColor",               Actor::Property::WORLD_COLOR,              Property::VECTOR4     },
3274   { "worldMatrix",              Actor::Property::WORLD_MATRIX,             Property::MATRIX      },
3275   { "name",                     Actor::Property::NAME,                     Property::STRING      },
3276   { "sensitive",                Actor::Property::SENSITIVE,                Property::BOOLEAN     },
3277   { "leaveRequired",            Actor::Property::LEAVE_REQUIRED,           Property::BOOLEAN     },
3278   { "inheritOrientation",       Actor::Property::INHERIT_ORIENTATION,      Property::BOOLEAN     },
3279   { "inheritScale",             Actor::Property::INHERIT_SCALE,            Property::BOOLEAN     },
3280   { "colorMode",                Actor::Property::COLOR_MODE,               Property::STRING      },
3281   { "drawMode",                 Actor::Property::DRAW_MODE,                Property::STRING      },
3282   { "sizeModeFactor",           Actor::Property::SIZE_MODE_FACTOR,         Property::VECTOR3     },
3283   { "widthResizePolicy",        Actor::Property::WIDTH_RESIZE_POLICY,      Property::STRING      },
3284   { "heightResizePolicy",       Actor::Property::HEIGHT_RESIZE_POLICY,     Property::STRING      },
3285   { "sizeScalePolicy",          Actor::Property::SIZE_SCALE_POLICY,        Property::STRING      },
3286   { "widthForHeight",           Actor::Property::WIDTH_FOR_HEIGHT,         Property::BOOLEAN     },
3287   { "heightForWidth",           Actor::Property::HEIGHT_FOR_WIDTH,         Property::BOOLEAN     },
3288   { "padding",                  Actor::Property::PADDING,                  Property::VECTOR4     },
3289   { "minimumSize",              Actor::Property::MINIMUM_SIZE,             Property::VECTOR2     },
3290   { "maximumSize",              Actor::Property::MAXIMUM_SIZE,             Property::VECTOR2     },
3291   { "inheritPosition",          Actor::Property::INHERIT_POSITION,         Property::BOOLEAN     },
3292   { "clippingMode",             Actor::Property::CLIPPING_MODE,            Property::STRING      },
3293   { "opacity",                  DevelActor::Property::OPACITY,             Property::FLOAT       },
3294   { "updateSizeHint",           DevelActor::Property::UPDATE_SIZE_HINT,    Property::VECTOR2     },
3295 };
3296 const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
3297 } // unnamed namespace
3298
3299 int UtcDaliActorProperties(void)
3300 {
3301   TestApplication app;
3302
3303   Actor actor = Actor::New();
3304
3305   for ( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
3306   {
3307     tet_printf( "Checking %s == %d\n", PROPERTY_TABLE[i].name, PROPERTY_TABLE[i].index );
3308     DALI_TEST_EQUALS( actor.GetPropertyName( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].name, TEST_LOCATION );
3309     DALI_TEST_EQUALS( actor.GetPropertyIndex( PROPERTY_TABLE[i].name ), PROPERTY_TABLE[i].index, TEST_LOCATION );
3310     DALI_TEST_EQUALS( actor.GetPropertyType( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].type, TEST_LOCATION );
3311   }
3312   END_TEST;
3313 }
3314
3315 int UtcDaliRelayoutProperties_ResizePolicies(void)
3316 {
3317   TestApplication app;
3318
3319   Actor actor = Actor::New();
3320
3321   // Defaults
3322   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
3323   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
3324
3325   // Set resize policy for all dimensions
3326   actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
3327   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i)
3328   {
3329     DALI_TEST_EQUALS( actor.GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) ), ResizePolicy::USE_NATURAL_SIZE, TEST_LOCATION );
3330   }
3331
3332   // Set individual dimensions
3333   const char* const widthPolicy = "FILL_TO_PARENT";
3334   const char* const heightPolicy = "FIXED";
3335
3336   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy );
3337   actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy );
3338
3339   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), widthPolicy, TEST_LOCATION );
3340   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), heightPolicy, TEST_LOCATION );
3341
3342   // Set individual dimensions using enums
3343   ResizePolicy::Type widthPolicyEnum = ResizePolicy::USE_ASSIGNED_SIZE;
3344   ResizePolicy::Type heightPolicyEnum = ResizePolicy::SIZE_RELATIVE_TO_PARENT;
3345
3346   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum );
3347   actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum );
3348
3349   DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::WIDTH ) ), static_cast< int >( widthPolicyEnum ), TEST_LOCATION );
3350   DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::HEIGHT ) ), static_cast< int >( heightPolicyEnum ), TEST_LOCATION );
3351
3352   END_TEST;
3353 }
3354
3355 int UtcDaliRelayoutProperties_SizeScalePolicy(void)
3356 {
3357   TestApplication app;
3358
3359   Actor actor = Actor::New();
3360
3361   // Defaults
3362   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), "USE_SIZE_SET", TEST_LOCATION );
3363   DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION );
3364
3365   SizeScalePolicy::Type policy = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
3366   actor.SetSizeScalePolicy( policy );
3367   DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), policy, TEST_LOCATION );
3368
3369   // Set
3370   const char* const policy1 = "FIT_WITH_ASPECT_RATIO";
3371   const char* const policy2 = "FILL_WITH_ASPECT_RATIO";
3372
3373   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy1 );
3374   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy1, TEST_LOCATION );
3375
3376   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy2 );
3377   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy2, TEST_LOCATION );
3378
3379   END_TEST;
3380 }
3381
3382 int UtcDaliRelayoutProperties_SizeModeFactor(void)
3383 {
3384   TestApplication app;
3385
3386   Actor actor = Actor::New();
3387
3388   // Defaults
3389   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
3390   DALI_TEST_EQUALS( actor.GetSizeModeFactor(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
3391
3392   Vector3 sizeMode( 1.0f, 2.0f, 3.0f );
3393   actor.SetSizeModeFactor( sizeMode );
3394   DALI_TEST_EQUALS( actor.GetSizeModeFactor(), sizeMode, TEST_LOCATION );
3395
3396   // Set
3397   Vector3 sizeMode1( 2.0f, 3.0f, 4.0f );
3398
3399   actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, sizeMode1 );
3400   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), sizeMode1, TEST_LOCATION );
3401
3402   END_TEST;
3403 }
3404
3405 int UtcDaliRelayoutProperties_DimensionDependency(void)
3406 {
3407   TestApplication app;
3408
3409   Actor actor = Actor::New();
3410
3411   // Defaults
3412   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
3413   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), false, TEST_LOCATION );
3414
3415   // Set
3416   actor.SetProperty( Actor::Property::WIDTH_FOR_HEIGHT, true );
3417   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), true, TEST_LOCATION );
3418
3419   actor.SetProperty( Actor::Property::HEIGHT_FOR_WIDTH, true );
3420   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), true, TEST_LOCATION );
3421
3422   // Test setting another resize policy
3423   actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FIXED" );
3424   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
3425
3426   END_TEST;
3427 }
3428
3429 int UtcDaliRelayoutProperties_Padding(void)
3430 {
3431   TestApplication app;
3432
3433   Actor actor = Actor::New();
3434
3435   // Data
3436   Vector4 padding( 1.0f, 2.0f, 3.0f, 4.0f );
3437
3438   // PADDING
3439   actor.SetProperty( Actor::Property::PADDING, padding );
3440   Vector4 paddingResult = actor.GetProperty( Actor::Property::PADDING ).Get< Vector4 >();
3441
3442   DALI_TEST_EQUALS( paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3443
3444   END_TEST;
3445 }
3446
3447 int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
3448 {
3449   TestApplication app;
3450
3451   Actor actor = Actor::New();
3452
3453   // Data
3454   Vector2 minSize( 1.0f, 2.0f );
3455
3456   actor.SetProperty( Actor::Property::MINIMUM_SIZE, minSize );
3457   Vector2 resultMin = actor.GetProperty( Actor::Property::MINIMUM_SIZE ).Get< Vector2 >();
3458
3459   DALI_TEST_EQUALS( resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3460
3461   Vector2 maxSize( 3.0f, 4.0f );
3462
3463   actor.SetProperty( Actor::Property::MAXIMUM_SIZE, maxSize );
3464   Vector2 resultMax = actor.GetProperty( Actor::Property::MAXIMUM_SIZE ).Get< Vector2 >();
3465
3466   DALI_TEST_EQUALS( resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
3467
3468   END_TEST;
3469 }
3470
3471 int UtcDaliActorGetHeightForWidth(void)
3472 {
3473   TestApplication app;
3474
3475   Actor actor = Actor::New();
3476
3477   DALI_TEST_EQUALS( actor.GetHeightForWidth( 1.0f ), 1.0f, TEST_LOCATION );
3478
3479   END_TEST;
3480 }
3481
3482 int UtcDaliActorGetWidthForHeight(void)
3483 {
3484   TestApplication app;
3485
3486   Actor actor = Actor::New();
3487
3488   DALI_TEST_EQUALS( actor.GetWidthForHeight( 1.0f ), 1.0f, TEST_LOCATION );
3489
3490   END_TEST;
3491 }
3492
3493 int UtcDaliActorGetRelayoutSize(void)
3494 {
3495   TestApplication app;
3496
3497   Actor actor = Actor::New();
3498
3499   // Add actor to stage
3500   Stage::GetCurrent().Add( actor );
3501
3502   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 0.0f, TEST_LOCATION );
3503
3504   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
3505   actor.SetSize( Vector2( 1.0f, 0.0f ) );
3506
3507   // Flush the queue and render once
3508   app.SendNotification();
3509   app.Render();
3510
3511   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 1.0f, TEST_LOCATION );
3512
3513   END_TEST;
3514 }
3515
3516 int UtcDaliActorSetPadding(void)
3517 {
3518   TestApplication app;
3519
3520   Actor actor = Actor::New();
3521
3522   Padding padding;
3523   actor.GetPadding( padding );
3524
3525   DALI_TEST_EQUALS( padding.left, 0.0f, TEST_LOCATION );
3526   DALI_TEST_EQUALS( padding.right, 0.0f, TEST_LOCATION );
3527   DALI_TEST_EQUALS( padding.bottom, 0.0f, TEST_LOCATION );
3528   DALI_TEST_EQUALS( padding.top, 0.0f, TEST_LOCATION );
3529
3530   Padding padding2( 1.0f, 2.0f, 3.0f, 4.0f );
3531   actor.SetPadding( padding2 );
3532
3533   actor.GetPadding( padding );
3534
3535   DALI_TEST_EQUALS( padding.left, padding2.left, TEST_LOCATION );
3536   DALI_TEST_EQUALS( padding.right, padding2.right, TEST_LOCATION );
3537   DALI_TEST_EQUALS( padding.bottom, padding2.bottom, TEST_LOCATION );
3538   DALI_TEST_EQUALS( padding.top, padding2.top, TEST_LOCATION );
3539
3540   END_TEST;
3541 }
3542
3543 int UtcDaliActorSetMinimumSize(void)
3544 {
3545   TestApplication app;
3546
3547   Actor actor = Actor::New();
3548
3549   Vector2 size = actor.GetMinimumSize();
3550
3551   DALI_TEST_EQUALS( size.width, 0.0f, TEST_LOCATION );
3552   DALI_TEST_EQUALS( size.height, 0.0f, TEST_LOCATION );
3553
3554   Vector2 size2( 1.0f, 2.0f );
3555   actor.SetMinimumSize( size2 );
3556
3557   size = actor.GetMinimumSize();
3558
3559   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
3560   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
3561
3562   END_TEST;
3563 }
3564
3565 int UtcDaliActorSetMaximumSize(void)
3566 {
3567   TestApplication app;
3568
3569   Actor actor = Actor::New();
3570
3571   Vector2 size = actor.GetMaximumSize();
3572
3573   DALI_TEST_EQUALS( size.width, FLT_MAX, TEST_LOCATION );
3574   DALI_TEST_EQUALS( size.height, FLT_MAX, TEST_LOCATION );
3575
3576   Vector2 size2( 1.0f, 2.0f );
3577   actor.SetMaximumSize( size2 );
3578
3579   size = actor.GetMaximumSize();
3580
3581   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
3582   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
3583
3584   END_TEST;
3585 }
3586
3587 int UtcDaliActorOnRelayoutSignal(void)
3588 {
3589   tet_infoline("Testing Dali::Actor::OnRelayoutSignal()");
3590
3591   TestApplication application;
3592
3593   // Clean test data
3594   gOnRelayoutCallBackCalled = false;
3595   gActorNamesRelayout.clear();
3596
3597   Actor actor = Actor::New();
3598   actor.SetName( "actor" );
3599   actor.OnRelayoutSignal().Connect( OnRelayoutCallback );
3600
3601   // Sanity check
3602   DALI_TEST_CHECK( ! gOnRelayoutCallBackCalled );
3603
3604   // Add actor to stage
3605   Stage::GetCurrent().Add( actor );
3606
3607   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
3608   actor.SetSize( Vector2( 1.0f, 2.0 ) );
3609
3610   // Flush the queue and render once
3611   application.SendNotification();
3612   application.Render();
3613
3614   // OnRelayout emitted
3615   DALI_TEST_EQUALS(  gOnRelayoutCallBackCalled, true, TEST_LOCATION );
3616   DALI_TEST_EQUALS( "actor", gActorNamesRelayout[ 0 ], TEST_LOCATION );
3617
3618   END_TEST;
3619 }
3620
3621 int UtcDaliActorGetHierachyDepth(void)
3622 {
3623   TestApplication application;
3624   tet_infoline("Testing Dali::Actor::GetHierarchyDepth()");
3625
3626
3627   /* Build tree of actors:
3628    *
3629    *                      Depth
3630    *
3631    *       A (parent)       1
3632    *      / \
3633    *     B   C              2`
3634    *    / \   \
3635    *   D   E   F            3
3636    *
3637    * GetHierarchyDepth should return 1 for A, 2 for B and C, and 3 for D, E and F.
3638    */
3639   Stage stage( Stage::GetCurrent() );
3640
3641   Actor actorA = Actor::New();
3642   Actor actorB = Actor::New();
3643   Actor actorC = Actor::New();
3644   Actor actorD = Actor::New();
3645   Actor actorE = Actor::New();
3646   Actor actorF = Actor::New();
3647
3648   //Test that root actor has depth equal 0
3649   DALI_TEST_EQUALS( 0, stage.GetRootLayer().GetHierarchyDepth(), TEST_LOCATION );
3650
3651   //Test actors return depth -1 when not connected to the tree
3652   DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3653   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3654   DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
3655   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3656   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3657   DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
3658
3659   //Create the hierarchy
3660   stage.Add( actorA );
3661   actorA.Add( actorB );
3662   actorA.Add( actorC );
3663   actorB.Add( actorD );
3664   actorB.Add( actorE );
3665   actorC.Add( actorF );
3666
3667   //Test actors return correct depth
3668   DALI_TEST_EQUALS( 1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3669   DALI_TEST_EQUALS( 2, actorB.GetHierarchyDepth(), TEST_LOCATION );
3670   DALI_TEST_EQUALS( 2, actorC.GetHierarchyDepth(), TEST_LOCATION );
3671   DALI_TEST_EQUALS( 3, actorD.GetHierarchyDepth(), TEST_LOCATION );
3672   DALI_TEST_EQUALS( 3, actorE.GetHierarchyDepth(), TEST_LOCATION );
3673   DALI_TEST_EQUALS( 3, actorF.GetHierarchyDepth(), TEST_LOCATION );
3674
3675   //Removing actorB from the hierarchy. actorB, actorD and actorE should now have depth equal -1
3676   actorA.Remove( actorB );
3677
3678   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3679   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3680   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3681
3682   //Removing actorA from the stage. All actors should have depth equal -1
3683   stage.Remove( actorA );
3684
3685   DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
3686   DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
3687   DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
3688   DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
3689   DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
3690   DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
3691
3692   END_TEST;
3693 }
3694
3695 int UtcDaliActorAnchorPointPropertyAsString(void)
3696 {
3697   TestApplication application;
3698
3699   Actor actor = Actor::New();
3700
3701   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_LEFT" );
3702   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
3703
3704   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_CENTER" );
3705   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
3706
3707   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_RIGHT" );
3708   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
3709
3710   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_LEFT" );
3711   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
3712
3713   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER" );
3714   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER, TEST_LOCATION );
3715
3716   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_RIGHT" );
3717   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
3718
3719   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT" );
3720   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
3721
3722   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER" );
3723   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
3724
3725   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT" );
3726   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3727
3728   // Invalid should not change anything
3729   actor.SetProperty( Actor::Property::ANCHOR_POINT, "INVALID_ARG" );
3730   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3731
3732   END_TEST;
3733 }
3734
3735 int UtcDaliActorParentOriginPropertyAsString(void)
3736 {
3737   TestApplication application;
3738
3739   Actor actor = Actor::New();
3740
3741   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_LEFT" );
3742   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
3743
3744   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_CENTER" );
3745   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
3746
3747   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_RIGHT" );
3748   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
3749
3750   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_LEFT" );
3751   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
3752
3753   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER" );
3754   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER, TEST_LOCATION );
3755
3756   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT" );
3757   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
3758
3759   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT" );
3760   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
3761
3762   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER" );
3763   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
3764
3765   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT" );
3766   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3767
3768   // Invalid should not change anything
3769   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "INVALID_ARG" );
3770   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
3771
3772   END_TEST;
3773 }
3774
3775 int UtcDaliActorColorModePropertyAsString(void)
3776 {
3777   TestApplication application;
3778
3779   Actor actor = Actor::New();
3780
3781   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_COLOR" );
3782   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
3783
3784   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_PARENT_COLOR" );
3785   DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
3786
3787   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR" );
3788   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
3789
3790   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA" );
3791   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3792
3793   // Invalid should not change anything
3794   actor.SetProperty( Actor::Property::COLOR_MODE, "INVALID_ARG" );
3795   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3796
3797   END_TEST;
3798 }
3799
3800 int UtcDaliActorDrawModePropertyAsString(void)
3801 {
3802   TestApplication application;
3803
3804   Actor actor = Actor::New();
3805
3806   actor.SetProperty( Actor::Property::DRAW_MODE, "NORMAL" );
3807   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
3808
3809   actor.SetProperty( Actor::Property::DRAW_MODE, "OVERLAY_2D" );
3810   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3811
3812   // Invalid should not change anything
3813   actor.SetProperty( Actor::Property::DRAW_MODE, "INVALID_ARG" );
3814   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3815
3816   END_TEST;
3817 }
3818
3819 int UtcDaliActorColorModePropertyAsEnum(void)
3820 {
3821   TestApplication application;
3822
3823   Actor actor = Actor::New();
3824
3825   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
3826   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
3827
3828   actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
3829   DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
3830
3831   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
3832   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
3833
3834   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
3835   DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
3836
3837   END_TEST;
3838 }
3839
3840 int UtcDaliActorDrawModePropertyAsEnum(void)
3841 {
3842   TestApplication application;
3843
3844   Actor actor = Actor::New();
3845
3846   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
3847   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
3848
3849   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
3850   DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
3851
3852   END_TEST;
3853 }
3854
3855 int UtcDaliActorAddRendererP(void)
3856 {
3857   tet_infoline("Testing Actor::AddRenderer");
3858   TestApplication application;
3859
3860   Actor actor = Actor::New();
3861
3862   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3863
3864   Geometry geometry = CreateQuadGeometry();
3865   Shader shader = CreateShader();
3866   Renderer renderer = Renderer::New(geometry, shader);
3867
3868   actor.AddRenderer( renderer );
3869   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3870   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3871
3872   END_TEST;
3873 }
3874
3875 int UtcDaliActorAddRendererN(void)
3876 {
3877   tet_infoline("Testing Actor::AddRenderer");
3878   TestApplication application;
3879
3880   Actor actor = Actor::New();
3881   Renderer renderer;
3882
3883   // try illegal Add
3884   try
3885   {
3886     actor.AddRenderer( renderer );
3887     tet_printf("Assertion test failed - no Exception\n" );
3888     tet_result(TET_FAIL);
3889   }
3890   catch(Dali::DaliException& e)
3891   {
3892     DALI_TEST_PRINT_ASSERT( e );
3893     DALI_TEST_ASSERT(e, "Renderer handle is empty", TEST_LOCATION);
3894     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3895   }
3896   catch(...)
3897   {
3898     tet_printf("Assertion test failed - wrong Exception\n" );
3899     tet_result(TET_FAIL);
3900   }
3901
3902   END_TEST;
3903 }
3904
3905 int UtcDaliActorAddRendererOnStage(void)
3906 {
3907   tet_infoline("Testing Actor::AddRenderer");
3908   TestApplication application;
3909
3910   Actor actor = Actor::New();
3911   Stage::GetCurrent().Add(actor);
3912
3913   application.SendNotification();
3914   application.Render(0);
3915
3916   Geometry geometry = CreateQuadGeometry();
3917   Shader shader = CreateShader();
3918   Renderer renderer = Renderer::New(geometry, shader);
3919
3920   application.SendNotification();
3921   application.Render(0);
3922
3923   try
3924   {
3925     actor.AddRenderer( renderer );
3926     tet_result(TET_PASS);
3927   }
3928   catch(...)
3929   {
3930     tet_result(TET_FAIL);
3931   }
3932
3933   END_TEST;
3934 }
3935
3936 int UtcDaliActorRemoveRendererP1(void)
3937 {
3938   tet_infoline("Testing Actor::RemoveRenderer");
3939   TestApplication application;
3940
3941   Actor actor = Actor::New();
3942
3943   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3944
3945   {
3946     Geometry geometry = CreateQuadGeometry();
3947     Shader shader = CreateShader();
3948     Renderer renderer = Renderer::New(geometry, shader);
3949
3950     actor.AddRenderer( renderer );
3951     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3952     DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3953
3954     application.SendNotification();
3955     application.Render();
3956   }
3957
3958   {
3959     Renderer renderer = actor.GetRendererAt(0);
3960     actor.RemoveRenderer(renderer);
3961     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3962
3963     application.SendNotification();
3964     application.Render();
3965   }
3966
3967   // Call one final time to ensure that the renderer is actually removed after
3968   // the handle goes out of scope, and excercises the deletion code path in
3969   // scene graph and render.
3970   application.SendNotification();
3971   application.Render();
3972
3973   END_TEST;
3974 }
3975
3976 int UtcDaliActorRemoveRendererP2(void)
3977 {
3978   tet_infoline("Testing Actor::RemoveRenderer");
3979   TestApplication application;
3980
3981   Actor actor = Actor::New();
3982
3983   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
3984
3985   Geometry geometry = CreateQuadGeometry();
3986   Shader shader = CreateShader();
3987   Renderer renderer = Renderer::New(geometry, shader);
3988
3989   actor.AddRenderer( renderer );
3990   application.SendNotification();
3991   application.Render();
3992
3993   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
3994   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
3995
3996   actor.RemoveRenderer(0);
3997   application.SendNotification();
3998   application.Render();
3999
4000   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
4001
4002   // Shut down whilst holding onto the renderer handle.
4003   END_TEST;
4004 }
4005
4006
4007 int UtcDaliActorRemoveRendererN(void)
4008 {
4009   tet_infoline("Testing Actor::RemoveRenderer");
4010   TestApplication application;
4011
4012   Actor actor = Actor::New();
4013
4014   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
4015
4016   Geometry geometry = CreateQuadGeometry();
4017   Shader shader = CreateShader();
4018   Renderer renderer = Renderer::New(geometry, shader);
4019
4020   actor.AddRenderer( renderer );
4021   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
4022   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
4023
4024   actor.RemoveRenderer(10);
4025   DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
4026   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
4027
4028   END_TEST;
4029 }
4030
4031 // Clipping test helper functions:
4032 Actor CreateActorWithContent( uint32_t width, uint32_t height)
4033 {
4034   BufferImage image = BufferImage::New( width, height );
4035   Actor actor = CreateRenderableActor( image );
4036
4037   // Setup dimensions and position so actor is not skipped by culling.
4038   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
4039   actor.SetSize( width, height );
4040   actor.SetParentOrigin( ParentOrigin::CENTER );
4041   actor.SetAnchorPoint( AnchorPoint::CENTER );
4042
4043   return actor;
4044 }
4045
4046 Actor CreateActorWithContent16x16()
4047 {
4048   return CreateActorWithContent( 16, 16 );
4049 }
4050
4051 void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
4052 {
4053   enabledDisableTrace.Reset();
4054   stencilTrace.Reset();
4055   enabledDisableTrace.Enable( true );
4056   stencilTrace.Enable( true );
4057
4058   application.SendNotification();
4059   application.Render();
4060
4061   enabledDisableTrace.Enable( false );
4062   stencilTrace.Enable( false );
4063 }
4064
4065 void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue )
4066 {
4067   const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
4068
4069   DALI_TEST_EQUALS<bool>( colorMaskParams.red,   maskValue, TEST_LOCATION );
4070   DALI_TEST_EQUALS<bool>( colorMaskParams.green, maskValue, TEST_LOCATION );
4071   DALI_TEST_EQUALS<bool>( colorMaskParams.blue,  maskValue, TEST_LOCATION );
4072   DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, maskValue, TEST_LOCATION );
4073 }
4074
4075 int UtcDaliActorPropertyClippingP(void)
4076 {
4077   // This test checks the clippingMode property.
4078   tet_infoline( "Testing Actor::Property::ClippingMode: P" );
4079   TestApplication application;
4080
4081   Actor actor = Actor::New();
4082
4083   // Check default clippingEnabled value.
4084   Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
4085
4086   int value = 0;
4087   bool getValueResult = getValue.Get( value );
4088   DALI_TEST_CHECK( getValueResult );
4089
4090   if( getValueResult )
4091   {
4092     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4093   }
4094
4095   // Check setting the property to the stencil mode.
4096   actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4097
4098   // Check the new value was set.
4099   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4100   getValueResult = getValue.Get( value );
4101   DALI_TEST_CHECK( getValueResult );
4102
4103   if( getValueResult )
4104   {
4105     DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
4106   }
4107
4108   // Check setting the property to the scissor mode.
4109   actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4110
4111   // Check the new value was set.
4112   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4113   getValueResult = getValue.Get( value );
4114   DALI_TEST_CHECK( getValueResult );
4115
4116   if( getValueResult )
4117   {
4118     DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION );
4119   }
4120   END_TEST;
4121 }
4122
4123 int UtcDaliActorPropertyClippingN(void)
4124 {
4125   // Negative test case for Clipping.
4126   tet_infoline( "Testing Actor::Property::ClippingMode: N" );
4127   TestApplication application;
4128
4129   Actor actor = Actor::New();
4130
4131   // Check default clippingEnabled value.
4132   Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
4133
4134   int value = 0;
4135   bool getValueResult = getValue.Get( value );
4136   DALI_TEST_CHECK( getValueResult );
4137
4138   if( getValueResult )
4139   {
4140     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4141   }
4142
4143   // Check setting an invalid property value won't change the current property value.
4144   actor.SetProperty( Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY" );
4145
4146   getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
4147   getValueResult = getValue.Get( value );
4148   DALI_TEST_CHECK( getValueResult );
4149
4150   if( getValueResult )
4151   {
4152     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
4153   }
4154
4155   END_TEST;
4156 }
4157
4158 int UtcDaliActorPropertyClippingActor(void)
4159 {
4160   // This test checks that an actor is correctly setup for clipping.
4161   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor" );
4162   TestApplication application;
4163
4164   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4165   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4166   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4167   size_t startIndex = 0u;
4168
4169   // Create a clipping actor.
4170   Actor actorDepth1Clip = CreateActorWithContent16x16();
4171   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4172   Stage::GetCurrent().Add( actorDepth1Clip );
4173
4174   // Gather the call trace.
4175   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4176
4177   // Check we are writing to the color buffer.
4178   CheckColorMask( glAbstraction, true );
4179
4180   // Check the stencil buffer was enabled.
4181   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4182
4183   // Check the stencil buffer was cleared.
4184   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4185
4186   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4187   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );     // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4188   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
4189   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4190
4191   END_TEST;
4192 }
4193
4194 int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
4195 {
4196   // This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
4197   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable" );
4198   TestApplication application;
4199
4200   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4201   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4202   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4203   size_t startIndex = 0u;
4204
4205   // Create a clipping actor.
4206   Actor actorDepth1Clip = CreateActorWithContent16x16();
4207   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4208   Stage::GetCurrent().Add( actorDepth1Clip );
4209
4210   // Gather the call trace.
4211   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4212
4213   // Check we are writing to the color buffer.
4214   CheckColorMask( glAbstraction, true );
4215
4216   // Check the stencil buffer was enabled.
4217   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4218
4219   // Check the stencil buffer was cleared.
4220   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4221
4222   // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4223   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );     // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4224   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
4225   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4226
4227   // Now disable the clipping
4228   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
4229
4230   // Gather the call trace.
4231   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4232
4233   // Check the stencil buffer was disabled.
4234   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Disable", "2960" ) );                                   // 2960 is GL_STENCIL_TEST
4235
4236   // Ensure all values in stencil-mask are set to 1.
4237   startIndex = 0u;
4238   DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "255", startIndex ) );
4239
4240   END_TEST;
4241 }
4242
4243 int UtcDaliActorPropertyClippingNestedChildren(void)
4244 {
4245   // This test checks that a hierarchy of actors are clipped correctly by
4246   // writing to and reading from the correct bit-planes of the stencil buffer.
4247   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children" );
4248   TestApplication application;
4249   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4250   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4251   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4252
4253   // Create a clipping actor.
4254   Actor actorDepth1Clip = CreateActorWithContent16x16();
4255   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4256   Stage::GetCurrent().Add( actorDepth1Clip );
4257
4258   // Create a child actor.
4259   Actor childDepth2 = CreateActorWithContent16x16();
4260   actorDepth1Clip.Add( childDepth2 );
4261
4262   // Create another clipping actor.
4263   Actor childDepth2Clip = CreateActorWithContent16x16();
4264   childDepth2Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4265   childDepth2.Add( childDepth2Clip );
4266
4267   // Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
4268   // This tests the sort algorithm.
4269   Actor childDepth3 = CreateActorWithContent16x16();
4270   childDepth2Clip.Add( childDepth3 );
4271   Actor childDepth4 = CreateActorWithContent16x16();
4272   childDepth3.Add( childDepth4 );
4273
4274   // Gather the call trace.
4275   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4276
4277   // Check we are writing to the color buffer.
4278   CheckColorMask( glAbstraction, true );
4279
4280   // Check the stencil buffer was enabled.
4281   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );                                        // 2960 is GL_STENCIL_TEST
4282
4283   // Perform the test twice, once for 2D layer, and once for 3D.
4284   for( unsigned int i = 0u ; i < 2u; ++i )
4285   {
4286     size_t startIndex = 0u;
4287
4288     // Check the stencil buffer was cleared.
4289     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
4290
4291     // Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
4292     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 0", startIndex ) );        // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
4293     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask",  "1", startIndex ) );                // Write to the first bit-plane
4294     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4295
4296     // Check the correct setup was done to test against first bit-plane (only) of the stencil buffer.
4297     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 1, 255", startIndex ) );      // 514 is GL_EQUAL
4298     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
4299
4300     // Check we are set up to write to the second bitplane of the stencil buffer (only).
4301     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 3, 1", startIndex ) );        // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4302     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask",  "3", startIndex ) );                // Write to second (and previous) bit-planes
4303     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
4304
4305     // Check we are set up to test against both the first and second bit-planes of the stencil buffer.
4306     // (Both must be set to pass the check).
4307     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc",  "514, 3, 255", startIndex ) );      // 514 is GL_EQUAL, Test both bit-planes 1 & 2
4308     DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp",    "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
4309
4310     // If we are on the first loop, set the layer to 3D and loop to perform the test again.
4311     if( i == 0u )
4312     {
4313       Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_3D );
4314       GenerateTrace( application, enabledDisableTrace, stencilTrace );
4315     }
4316   }
4317
4318   END_TEST;
4319 }
4320
4321 int UtcDaliActorPropertyClippingActorDrawOrder(void)
4322 {
4323   // This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
4324   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order" );
4325   TestApplication application;
4326   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4327   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4328
4329   /* We create a small tree of actors as follows:
4330
4331                            A
4332                           / \
4333      Clipping enabled -> B   D
4334                          |   |
4335                          C   E
4336
4337      The correct draw order is "ABCDE" (the same as if clipping was not enabled).
4338   */
4339   Actor actors[5];
4340   for( int i = 0; i < 5; ++i )
4341   {
4342     BufferImage image = BufferImage::New( 16u, 16u );
4343     Actor actor = CreateRenderableActor( image );
4344
4345     // Setup dimensions and position so actor is not skipped by culling.
4346     actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
4347     actor.SetSize( 16.0f, 16.0f );
4348
4349     if( i == 0 )
4350     {
4351       actor.SetParentOrigin( ParentOrigin::CENTER );
4352     }
4353     else
4354     {
4355       float b = i > 2 ? 1.0f : -1.0f;
4356       actor.SetParentOrigin( Vector3( 0.5 + ( 0.2f * b ), 0.8f, 0.8f ) );
4357     }
4358
4359     actors[i] = actor;
4360   }
4361
4362   // Enable clipping on the actor at the top of the left branch.
4363   actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4364
4365   // Build the scene graph.
4366   Stage::GetCurrent().Add( actors[0] );
4367
4368   // Left branch:
4369   actors[0].Add( actors[1] );
4370   actors[1].Add( actors[2] );
4371
4372   // Right branch:
4373   actors[0].Add( actors[3] );
4374   actors[3].Add( actors[4] );
4375
4376   // Gather the call trace.
4377   enabledDisableTrace.Reset();
4378   enabledDisableTrace.Enable( true );
4379   application.SendNotification();
4380   application.Render();
4381   enabledDisableTrace.Enable( false );
4382
4383   /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
4384
4385      Note: Correct enable call trace:    StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960 StackTrace: Index:2, Function:Disable, ParamList:2960
4386            Incorrect enable call trace:  StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
4387   */
4388   size_t startIndex = 0u;
4389   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "3042", startIndex ) );
4390   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "2960", startIndex ) ); // 2960 is GL_STENCIL_TEST
4391   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
4392
4393   // Swap the clipping actor from top of left branch to top of right branch.
4394   actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
4395   actors[3].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4396
4397   // Gather the call trace.
4398   enabledDisableTrace.Reset();
4399   enabledDisableTrace.Enable( true );
4400   application.SendNotification();
4401   application.Render();
4402   enabledDisableTrace.Enable( false );
4403
4404   // Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
4405   // This proves the draw order has remained the same.
4406   startIndex = 0u;
4407   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex(  "Enable",  "2960", startIndex ) );
4408   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
4409
4410   END_TEST;
4411 }
4412
4413 int UtcDaliActorPropertyScissorClippingActor(void)
4414 {
4415   // This test checks that an actor is correctly setup for clipping.
4416   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor" );
4417   TestApplication application;
4418
4419   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4420   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4421   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4422
4423   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4424   const Vector2 imageSize( 16.0f, 16.0f );
4425
4426   // Create a clipping actor.
4427   Actor clippingActorA = CreateActorWithContent16x16();
4428   // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
4429   // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
4430   clippingActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
4431   clippingActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
4432   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4433   Stage::GetCurrent().Add( clippingActorA );
4434
4435   // Gather the call trace.
4436   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4437
4438   // Check we are writing to the color buffer.
4439   CheckColorMask( glAbstraction, true );
4440
4441   // Check scissor test was enabled.
4442   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4443
4444   // Check the scissor was set, and the coordinates are correct.
4445   std::stringstream compareParametersString;
4446   compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
4447   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 0, 0, 16, 16
4448
4449   clippingActorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
4450   clippingActorA.SetAnchorPoint( AnchorPoint::TOP_RIGHT );
4451
4452   // Gather the call trace.
4453   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4454
4455   // Check the scissor was set, and the coordinates are correct.
4456   compareParametersString.str( std::string() );
4457   compareParametersString.clear();
4458   compareParametersString << ( stageSize.x - imageSize.x ) << ", " << ( stageSize.y - imageSize.y ) << ", " << imageSize.x << ", " << imageSize.y;
4459   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 464, 784, 16, 16
4460
4461   END_TEST;
4462 }
4463
4464 int UtcDaliActorPropertyScissorClippingActorSiblings(void)
4465 {
4466   // This test checks that an actor is correctly setup for clipping.
4467   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings" );
4468   TestApplication application;
4469
4470
4471   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4472   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4473   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4474
4475   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4476   const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
4477   const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
4478
4479   // Create a clipping actors.
4480   Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
4481   Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
4482
4483   clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4484   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4485   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4486
4487   clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4488   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4489   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4490
4491   clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
4492   clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
4493
4494   Stage::GetCurrent().Add( clippingActorA );
4495   Stage::GetCurrent().Add( clippingActorB );
4496
4497   // Gather the call trace.
4498   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4499
4500   // Check we are writing to the color buffer.
4501   CheckColorMask( glAbstraction, true );
4502
4503   // Check scissor test was enabled.
4504   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4505
4506   // Check the scissor was set, and the coordinates are correct.
4507   std::stringstream compareParametersString;
4508
4509   std::string clipA( "0, 500, 480, 200" );
4510   std::string clipB( "0, 380, 480, 40" );
4511
4512   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
4513   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
4514
4515   END_TEST;
4516 }
4517
4518 int UtcDaliActorPropertyScissorClippingActorNested01(void)
4519 {
4520   // This test checks that an actor is correctly setup for clipping.
4521   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
4522   TestApplication application;
4523
4524   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4525   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4526   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4527
4528   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4529   const Vector2 imageSize( 16.0f, 16.0f );
4530
4531   /* Create a nest of 2 scissors to test nesting (intersecting clips).
4532
4533      A is drawn first - with scissor clipping on
4534      B is drawn second - also with scissor clipping on
4535      C is the generated clipping region, the intersection ( A ∩ B )
4536
4537            ┏━━━━━━━┓                   ┌───────┐
4538            ┃     B ┃                   │     B │
4539        ┌───╂┄┄┄┐   ┃               ┌┄┄┄╆━━━┓   │
4540        │   ┃   ┊   ┃     ━━━━━>    ┊   ┃ C ┃   │
4541        │   ┗━━━┿━━━┛               ┊   ┗━━━╃───┘
4542        │ A     │                   ┊ A     ┊
4543        └───────┘                   └┄┄┄┄┄┄┄┘
4544
4545      We then reposition B around each corner of A to test the 4 overlap combinations (thus testing intersecting works correctly).
4546   */
4547
4548   // Create a clipping actor.
4549   Actor clippingActorA = CreateActorWithContent16x16();
4550   // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
4551   // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
4552   clippingActorA.SetParentOrigin( ParentOrigin::CENTER );
4553   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER );
4554   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4555   Stage::GetCurrent().Add( clippingActorA );
4556
4557   // Create a child clipping actor.
4558   Actor clippingActorB = CreateActorWithContent16x16();
4559   clippingActorB.SetParentOrigin( ParentOrigin::CENTER );
4560   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER );
4561   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4562   clippingActorA.Add( clippingActorB );
4563
4564   // positionModifiers is an array of positions to position B around.
4565   // expect is an array of expected scissor clip coordinate results.
4566   const Vector2 positionModifiers[4] = { Vector2( 1.0f, 1.0f ),     Vector2( -1.0f, 1.0f ),    Vector2( -1.0f, -1.0f ),   Vector2( 1.0f, -1.0f )    };
4567   const Vector4 expect[4] =            { Vector4( 240, 392, 8, 8 ), Vector4( 232, 392, 8, 8 ), Vector4( 232, 400, 8, 8 ), Vector4( 240, 400, 8, 8 ) };
4568
4569   // Loop through each overlap combination.
4570   for( unsigned int test = 0u; test < 4u; ++test )
4571   {
4572     // Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
4573     const Vector2 position = ( imageSize / 2.0f ) * positionModifiers[test];
4574     clippingActorB.SetPosition( position.x, position.y );
4575
4576     // Gather the call trace.
4577     GenerateTrace( application, enabledDisableTrace, scissorTrace );
4578
4579     // Check we are writing to the color buffer.
4580     CheckColorMask( glAbstraction, true );
4581
4582     // Check scissor test was enabled.
4583     DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4584
4585     // Check the scissor was set, and the coordinates are correct.
4586     const Vector4& expectResults( expect[test] );
4587     std::stringstream compareParametersString;
4588     compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
4589     DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with the expected result
4590   }
4591
4592   END_TEST;
4593 }
4594
4595 int UtcDaliActorPropertyScissorClippingActorNested02(void)
4596 {
4597   // This test checks that an actor is correctly setup for clipping.
4598   tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
4599   TestApplication application;
4600
4601   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4602   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4603   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4604
4605   /* Create a nest of 2 scissors and siblings of the parent.
4606
4607             stage
4608               |
4609         ┌─────┐─────┐
4610         A     C     D
4611         |           |
4612         B           E
4613   */
4614
4615   const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
4616   const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
4617   const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
4618   const Vector2 sizeC{ stageSize.width, stageSize.height * 0.25f };
4619   const Vector2 sizeD{ stageSize.width, stageSize.height * 0.25f };
4620   const Vector2 sizeE{ stageSize.width, stageSize.height * 0.05f };
4621
4622   // Create a clipping actors.
4623   Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
4624   Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
4625   Actor clippingActorC = CreateActorWithContent( sizeC.width, sizeC.height );
4626   Actor clippingActorD = CreateActorWithContent( sizeD.width, sizeD.height );
4627   Actor clippingActorE = CreateActorWithContent( sizeE.width, sizeE.height );
4628
4629   clippingActorA.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4630   clippingActorA.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4631   clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4632
4633   clippingActorB.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4634   clippingActorB.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4635   clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4636
4637   clippingActorC.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4638   clippingActorC.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4639   clippingActorC.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4640
4641   clippingActorD.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4642   clippingActorD.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4643   clippingActorD.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4644
4645   clippingActorE.SetParentOrigin( ParentOrigin::CENTER_LEFT );
4646   clippingActorE.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
4647
4648   clippingActorA.SetPosition( 0.0f, -200.0f, 0.0f );
4649   clippingActorB.SetPosition( 0.0f, 0.0f, 0.0f );
4650   clippingActorC.SetPosition( 0.0f, 100.0f, 0.0f );
4651   clippingActorD.SetPosition( 0.0f, 0.0f, 0.0f );
4652   clippingActorE.SetPosition( 0.0f, 0.0f, 0.0f );
4653
4654   Stage::GetCurrent().Add( clippingActorA );
4655   clippingActorA.Add( clippingActorB );
4656   Stage::GetCurrent().Add( clippingActorC );
4657   Stage::GetCurrent().Add( clippingActorD );
4658   clippingActorD.Add( clippingActorE );
4659
4660   // Gather the call trace.
4661   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4662
4663   // Check we are writing to the color buffer.
4664   CheckColorMask( glAbstraction, true );
4665
4666   // Check scissor test was enabled.
4667   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
4668
4669   // Check the scissor was set, and the coordinates are correct.
4670   std::string clipA( "0, 500, 480, 200" );
4671   std::string clipB( "0, 580, 480, 40" );
4672   std::string clipC( "0, 200, 480, 200" );
4673   std::string clipD( "0, 300, 480, 200" );
4674
4675   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
4676   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
4677   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipC ) );
4678   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipD ) );
4679   DALI_TEST_CHECK( scissorTrace.CountMethod( "Scissor" ) == 4 );    // Scissor rect should not be changed in clippingActorE case. So count should be 4.
4680
4681   END_TEST;
4682 }
4683
4684 int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
4685 {
4686   // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
4687   tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
4688   TestApplication application;
4689
4690   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4691   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
4692   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
4693
4694   // Create a clipping actor.
4695   Actor actorDepth1Clip = CreateActorWithContent16x16();
4696   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
4697   Stage::GetCurrent().Add( actorDepth1Clip );
4698
4699   // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
4700   actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
4701
4702   // Gather the call trace.
4703   GenerateTrace( application, enabledDisableTrace, stencilTrace );
4704
4705   // Check we are writing to the color buffer.
4706   CheckColorMask( glAbstraction, true );
4707
4708   // Check the stencil buffer was not enabled.
4709   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) );    // 2960 is GL_STENCIL_TEST
4710
4711   // Check stencil functions are not called.
4712   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
4713   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
4714   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
4715
4716   // Check that scissor clipping is overriden by the renderer properties.
4717   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
4718
4719   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
4720
4721   // Gather the call trace.
4722   GenerateTrace( application, enabledDisableTrace, scissorTrace );
4723
4724   // Check the stencil buffer was not enabled.
4725   DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );    // 3089 = 0xC11 (GL_SCISSOR_TEST)
4726
4727   DALI_TEST_CHECK( !scissorTrace.FindMethod( "StencilFunc" ) );
4728
4729   END_TEST;
4730 }
4731
4732 int UtcDaliGetPropertyN(void)
4733 {
4734   tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
4735   TestApplication app;
4736
4737   Actor actor = Actor::New();
4738
4739   unsigned int propertyCount = actor.GetPropertyCount();
4740   DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
4741   END_TEST;
4742 }
4743
4744 int UtcDaliActorRaiseLower(void)
4745 {
4746   tet_infoline( "UtcDaliActor Raise and Lower test\n" );
4747
4748   TestApplication application;
4749
4750   Stage stage( Stage::GetCurrent() );
4751
4752   Actor actorA = Actor::New();
4753   Actor actorB = Actor::New();
4754   Actor actorC = Actor::New();
4755
4756   actorA.SetAnchorPoint( AnchorPoint::CENTER );
4757   actorA.SetParentOrigin( ParentOrigin::CENTER );
4758
4759   actorB.SetAnchorPoint( AnchorPoint::CENTER );
4760   actorB.SetParentOrigin( ParentOrigin::CENTER );
4761
4762   actorC.SetAnchorPoint( AnchorPoint::CENTER );
4763   actorC.SetParentOrigin( ParentOrigin::CENTER );
4764
4765   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4766   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4767
4768   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4769   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4770
4771   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4772   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4773
4774   stage.Add( actorA );
4775   stage.Add( actorB );
4776   stage.Add( actorC );
4777
4778   ResetTouchCallbacks();
4779
4780   application.SendNotification();
4781   application.Render();
4782
4783   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
4784   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
4785   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
4786
4787   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
4788   // Only top actor will get touched.
4789   actorA.TouchSignal().Connect( TestTouchCallback );
4790   actorB.TouchSignal().Connect( TestTouchCallback2 );
4791   actorC.TouchSignal().Connect( TestTouchCallback3 );
4792
4793   // Connect ChildOrderChangedSignal
4794   bool orderChangedSignal( false );
4795   Actor orderChangedActor;
4796   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
4797   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
4798
4799   Dali::Integration::Point point;
4800   point.SetDeviceId( 1 );
4801   point.SetState( PointState::DOWN );
4802   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
4803   Dali::Integration::TouchEvent touchEvent;
4804   touchEvent.AddPoint( point );
4805
4806   application.ProcessEvent( touchEvent );
4807
4808   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4809   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
4810   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
4811
4812   ResetTouchCallbacks();
4813
4814   tet_printf( "Testing Raising of Actor\n" );
4815
4816   int preActorOrder( 0 );
4817   int postActorOrder( 0 );
4818
4819   Property::Value value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4820   value.Get( preActorOrder );
4821
4822   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4823   actorB.Raise();
4824   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4825   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
4826
4827   // Ensure sort order is calculated before next touch event
4828   application.SendNotification();
4829
4830   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4831   value.Get( postActorOrder );
4832
4833   tet_printf( "Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
4834
4835   application.ProcessEvent( touchEvent );
4836
4837   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4838   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true , TEST_LOCATION );
4839   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false, TEST_LOCATION );
4840
4841   ResetTouchCallbacks();
4842
4843   tet_printf( "Testing Lowering of Actor\n" );
4844
4845   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4846   value.Get( preActorOrder );
4847
4848   orderChangedSignal = false;
4849
4850   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4851   actorB.Lower();
4852   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4853   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
4854
4855   application.SendNotification(); // ensure sort order calculated before next touch event
4856
4857   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
4858   value.Get( postActorOrder );
4859
4860   tet_printf( "Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
4861
4862   application.ProcessEvent( touchEvent );
4863
4864   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4865   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false , TEST_LOCATION );
4866   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true, TEST_LOCATION );
4867
4868   ResetTouchCallbacks();
4869
4870   END_TEST;
4871 }
4872
4873 int UtcDaliActorRaiseToTopLowerToBottom(void)
4874 {
4875   tet_infoline( "UtcDaliActorRaiseToTop and LowerToBottom test \n" );
4876
4877   TestApplication application;
4878
4879   Stage stage( Stage::GetCurrent() );
4880
4881   Actor actorA = Actor::New();
4882   Actor actorB = Actor::New();
4883   Actor actorC = Actor::New();
4884
4885   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
4886   // enables checking of which actor the uniform is assigned too
4887   Shader shaderA = CreateShader();
4888   shaderA.RegisterProperty( "uRendererColor",1.f);
4889
4890   Shader shaderB = CreateShader();
4891   shaderB.RegisterProperty( "uRendererColor", 2.f );
4892
4893   Shader shaderC = CreateShader();
4894   shaderC.RegisterProperty( "uRendererColor", 3.f );
4895
4896   Geometry geometry = CreateQuadGeometry();
4897
4898   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
4899   Renderer rendererA = Renderer::New(geometry, shaderA);
4900   actorA.AddRenderer(rendererA);
4901
4902   Renderer rendererB = Renderer::New(geometry, shaderB);
4903   actorB.AddRenderer(rendererB);
4904
4905   Renderer rendererC = Renderer::New(geometry, shaderC);
4906   actorC.AddRenderer(rendererC);
4907
4908   actorA.SetAnchorPoint( AnchorPoint::CENTER );
4909   actorA.SetParentOrigin( ParentOrigin::CENTER );
4910
4911   actorB.SetAnchorPoint( AnchorPoint::CENTER );
4912   actorB.SetParentOrigin( ParentOrigin::CENTER );
4913
4914   actorC.SetAnchorPoint( AnchorPoint::CENTER );
4915   actorC.SetParentOrigin( ParentOrigin::CENTER );
4916
4917   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4918   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4919
4920   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4921   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4922
4923   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
4924   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
4925
4926   stage.Add( actorA );
4927   stage.Add( actorB );
4928   stage.Add( actorC );
4929
4930   ResetTouchCallbacks();
4931
4932   // Connect ChildOrderChangedSignal
4933   bool orderChangedSignal( false );
4934   Actor orderChangedActor;
4935   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
4936   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
4937
4938   // Set up gl abstraction trace so can query the set uniform order
4939   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4940   glAbstraction.EnableSetUniformCallTrace(true);
4941   glAbstraction.ResetSetUniformCallStack();
4942
4943   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
4944
4945   application.SendNotification();
4946   application.Render();
4947
4948   tet_printf( "Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str() );
4949
4950
4951   // Test order of uniforms in stack
4952   int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
4953   int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
4954   int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
4955
4956   bool CBA = ( indexC > indexB) &&  ( indexB > indexA );
4957
4958   DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
4959
4960   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
4961   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
4962   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
4963
4964   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
4965   // Only top actor will get touched.
4966   actorA.TouchSignal().Connect( TestTouchCallback );
4967   actorB.TouchSignal().Connect( TestTouchCallback2 );
4968   actorC.TouchSignal().Connect( TestTouchCallback3 );
4969
4970   Dali::Integration::Point point;
4971   point.SetDeviceId( 1 );
4972   point.SetState( PointState::DOWN );
4973   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
4974   Dali::Integration::TouchEvent touchEvent;
4975   touchEvent.AddPoint( point );
4976
4977   application.ProcessEvent( touchEvent );
4978
4979   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
4980   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
4981   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
4982
4983   ResetTouchCallbacks();
4984
4985   tet_printf( "RaiseToTop ActorA\n" );
4986
4987   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
4988   actorA.RaiseToTop();
4989   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
4990   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
4991
4992   application.SendNotification(); // ensure sorting order is calculated before next touch event
4993
4994   application.ProcessEvent( touchEvent );
4995
4996   glAbstraction.ResetSetUniformCallStack();
4997   glSetUniformStack = glAbstraction.GetSetUniformTrace();
4998
4999   application.SendNotification();
5000   application.Render();
5001
5002   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5003
5004   // Test order of uniforms in stack
5005   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5006   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5007   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5008
5009   tet_infoline( "Testing A above C and B at bottom\n" );
5010   bool ACB = ( indexA > indexC) && ( indexC > indexB );
5011
5012   DALI_TEST_EQUALS( ACB, true, TEST_LOCATION );
5013
5014   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5015   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5016   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5017
5018   ResetTouchCallbacks();
5019
5020   tet_printf( "RaiseToTop ActorB\n" );
5021
5022   orderChangedSignal = false;
5023
5024   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5025   actorB.RaiseToTop();
5026   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5027   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5028
5029   application.SendNotification(); // Ensure sort order is calculated before next touch event
5030
5031   application.ProcessEvent( touchEvent );
5032
5033   glAbstraction.ResetSetUniformCallStack();
5034   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5035
5036   application.SendNotification();
5037   application.Render();
5038
5039   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5040
5041   // Test order of uniforms in stack
5042   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5043   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5044   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5045
5046   tet_infoline( "Testing B above A and C at bottom\n" );
5047   bool BAC = ( indexB > indexA ) && ( indexA > indexC );
5048
5049   DALI_TEST_EQUALS( BAC, true, TEST_LOCATION );
5050
5051   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5052   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5053   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5054
5055   ResetTouchCallbacks();
5056
5057   tet_printf( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
5058
5059   orderChangedSignal = false;
5060
5061   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5062   actorA.LowerToBottom();
5063   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5064   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5065
5066   application.SendNotification();
5067   application.Render();
5068
5069   orderChangedSignal = false;
5070
5071   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5072   actorB.LowerToBottom();
5073   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5074   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5075
5076   application.SendNotification();
5077   application.Render();
5078
5079   application.ProcessEvent( touchEvent );
5080
5081   glAbstraction.ResetSetUniformCallStack();
5082   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5083
5084   application.SendNotification();
5085   application.Render();
5086
5087   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5088
5089   // Test order of uniforms in stack
5090   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5091   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5092   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5093
5094   tet_infoline( "Testing C above A and B at bottom\n" );
5095   bool CAB = ( indexC > indexA ) && ( indexA > indexB );
5096
5097   DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
5098
5099   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5100   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5101   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5102
5103   ResetTouchCallbacks();
5104
5105   END_TEST;
5106 }
5107
5108 int UtcDaliActorRaiseAbove(void)
5109 {
5110   tet_infoline( "UtcDaliActor RaiseToAbove test \n" );
5111
5112   TestApplication application;
5113
5114   Stage stage( Stage::GetCurrent() );
5115
5116   Actor actorA = Actor::New();
5117   Actor actorB = Actor::New();
5118   Actor actorC = Actor::New();
5119
5120   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5121   actorA.SetParentOrigin( ParentOrigin::CENTER );
5122
5123   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5124   actorB.SetParentOrigin( ParentOrigin::CENTER );
5125
5126   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5127   actorC.SetParentOrigin( ParentOrigin::CENTER );
5128
5129   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5130   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5131
5132   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5133   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5134
5135   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5136   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5137
5138   stage.Add( actorA );
5139   stage.Add( actorB );
5140   stage.Add( actorC );
5141
5142   ResetTouchCallbacks();
5143
5144   application.SendNotification();
5145   application.Render();
5146
5147   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5148   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5149   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5150
5151   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5152   // Only top actor will get touched.
5153   actorA.TouchSignal().Connect( TestTouchCallback );
5154   actorB.TouchSignal().Connect( TestTouchCallback2 );
5155   actorC.TouchSignal().Connect( TestTouchCallback3 );
5156
5157   bool orderChangedSignal( false );
5158   Actor orderChangedActor;
5159   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5160   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5161
5162   Dali::Integration::Point point;
5163   point.SetDeviceId( 1 );
5164   point.SetState( PointState::DOWN );
5165   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5166   Dali::Integration::TouchEvent touchEvent;
5167   touchEvent.AddPoint( point );
5168
5169   application.ProcessEvent( touchEvent );
5170
5171   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5172   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5173   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5174
5175   ResetTouchCallbacks();
5176
5177   tet_printf( "Raise actor B Above Actor C\n" );
5178
5179   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5180   actorB.RaiseAbove( actorC );
5181   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5182   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5183
5184   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5185   application.SendNotification();
5186   application.ProcessEvent( touchEvent );
5187
5188   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5189   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5190   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5191
5192   ResetTouchCallbacks();
5193
5194   tet_printf( "Raise actor A Above Actor B\n" );
5195
5196   orderChangedSignal = false;
5197
5198   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5199   actorA.RaiseAbove( actorB );
5200   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5201   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5202
5203   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5204   application.SendNotification();
5205
5206   application.ProcessEvent( touchEvent ); // process a touch event on ordered actors.
5207
5208   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5209   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5210   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5211
5212   ResetTouchCallbacks();
5213
5214   END_TEST;
5215 }
5216
5217 int UtcDaliActorLowerBelow(void)
5218 {
5219   tet_infoline( "UtcDaliActor LowerBelow test \n" );
5220
5221   TestApplication application;
5222
5223   Stage stage( Stage::GetCurrent() );
5224
5225   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
5226   // enables checking of which actor the uniform is assigned too
5227   Shader shaderA = CreateShader();
5228   shaderA.RegisterProperty( "uRendererColor",1.f);
5229
5230   Shader shaderB = CreateShader();
5231   shaderB.RegisterProperty( "uRendererColor", 2.f );
5232
5233   Shader shaderC = CreateShader();
5234   shaderC.RegisterProperty( "uRendererColor", 3.f );
5235
5236   Actor actorA = Actor::New();
5237   Actor actorB = Actor::New();
5238   Actor actorC = Actor::New();
5239
5240   // Add renderers to Actors so ( uRendererColor, 1 ) is A, ( uRendererColor, 2 ) is B, and ( uRendererColor, 3 ) is C,
5241   Geometry geometry = CreateQuadGeometry();
5242
5243   Renderer rendererA = Renderer::New(geometry, shaderA);
5244   actorA.AddRenderer(rendererA);
5245
5246   Renderer rendererB = Renderer::New(geometry, shaderB);
5247   actorB.AddRenderer(rendererB);
5248
5249   Renderer rendererC = Renderer::New(geometry, shaderC);
5250   actorC.AddRenderer(rendererC);
5251
5252   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5253   actorA.SetParentOrigin( ParentOrigin::CENTER );
5254
5255   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5256   actorB.SetParentOrigin( ParentOrigin::CENTER );
5257
5258   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5259   actorC.SetParentOrigin( ParentOrigin::CENTER );
5260
5261   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5262   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5263
5264   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5265   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5266
5267   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5268   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5269
5270   Actor container = Actor::New();
5271   container.SetParentOrigin( ParentOrigin::CENTER );
5272   container.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
5273   stage.Add( container );
5274
5275   container.Add( actorA );
5276   container.Add( actorB );
5277   container.Add( actorC );
5278
5279   ResetTouchCallbacks();
5280
5281   // Connect ChildOrderChangedSignal
5282   bool orderChangedSignal( false );
5283   Actor orderChangedActor;
5284   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5285   DevelActor::ChildOrderChangedSignal( container ).Connect( &application, f ) ;
5286
5287   // Set up gl abstraction trace so can query the set uniform order
5288   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
5289   glAbstraction.EnableSetUniformCallTrace(true);
5290   glAbstraction.ResetSetUniformCallStack();
5291   TraceCallStack& glSetUniformStack = glAbstraction.GetSetUniformTrace();
5292
5293   glAbstraction.ResetSetUniformCallStack();
5294
5295   application.SendNotification();
5296   application.Render();
5297
5298   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5299
5300   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5301
5302   // Test order of uniforms in stack
5303   int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5304   int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5305   int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5306
5307   tet_infoline( "Testing C above B and A at bottom\n" );
5308   bool CBA = ( indexC > indexB) &&  ( indexB > indexA );
5309
5310   DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
5311
5312   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5313   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5314   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5315
5316   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5317   // Only top actor will get touched.
5318   actorA.TouchSignal().Connect( TestTouchCallback );
5319   actorB.TouchSignal().Connect( TestTouchCallback2 );
5320   actorC.TouchSignal().Connect( TestTouchCallback3 );
5321
5322   Dali::Integration::Point point;
5323   point.SetDeviceId( 1 );
5324   point.SetState( PointState::DOWN );
5325   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5326   Dali::Integration::TouchEvent touchEvent;
5327   touchEvent.AddPoint( point );
5328
5329   tet_infoline( "UtcDaliActor Test Set up completed \n" );
5330
5331   application.ProcessEvent( touchEvent );
5332
5333   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5334   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5335   DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
5336
5337   ResetTouchCallbacks();
5338
5339   tet_printf( "Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n" );
5340
5341   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5342   actorC.LowerBelow( actorB );
5343   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5344   DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
5345
5346   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5347   application.SendNotification();
5348   application.Render();
5349
5350   application.ProcessEvent( touchEvent ); // touch event
5351
5352   glAbstraction.ResetSetUniformCallStack();
5353   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5354
5355   application.SendNotification();
5356   application.Render();
5357
5358   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5359
5360   // Test order of uniforms in stack
5361   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5362   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5363   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5364
5365   tet_infoline( "Testing render order is A, C, B" );
5366   DALI_TEST_EQUALS( indexC > indexA, true, TEST_LOCATION );
5367   DALI_TEST_EQUALS( indexB > indexC, true, TEST_LOCATION );
5368
5369   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5370   DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
5371   DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
5372
5373   ResetTouchCallbacks();
5374
5375   tet_printf( "Lower actor C below Actor A leaving B on top\n" );
5376
5377   orderChangedSignal = false;
5378
5379   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5380   actorC.LowerBelow( actorA );
5381   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5382   DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
5383
5384   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5385   application.SendNotification();
5386   application.Render();
5387
5388   application.ProcessEvent( touchEvent );
5389
5390   glAbstraction.ResetSetUniformCallStack();
5391   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5392
5393   application.Render();
5394   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5395
5396   // Test order of uniforms in stack
5397   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5398   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5399   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5400
5401   DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
5402   DALI_TEST_EQUALS( indexB > indexA, true, TEST_LOCATION );
5403
5404   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5405   DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
5406   DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
5407
5408   ResetTouchCallbacks();
5409
5410   tet_printf( "Lower actor B below Actor C leaving A on top\n" );
5411
5412   orderChangedSignal = false;
5413
5414   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5415   actorB.LowerBelow( actorC );
5416   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5417   DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
5418
5419   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5420   application.SendNotification();
5421   application.Render();
5422
5423   application.ProcessEvent( touchEvent );
5424
5425   glAbstraction.ResetSetUniformCallStack();
5426   glSetUniformStack = glAbstraction.GetSetUniformTrace();
5427
5428   application.Render();
5429   tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
5430
5431   // Test order of uniforms in stack
5432   indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "3" );
5433   indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "2" );
5434   indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor",  "1" );
5435
5436   DALI_TEST_EQUALS( indexC > indexB, true, TEST_LOCATION );
5437   DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
5438
5439   END_TEST;
5440 }
5441
5442
5443 int UtcDaliActorRaiseAboveDifferentParentsN(void)
5444 {
5445   tet_infoline( "UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n" );
5446
5447   TestApplication application;
5448
5449   Stage stage( Stage::GetCurrent() );
5450
5451   Actor parentA = Actor::New();
5452   Actor parentB = Actor::New();
5453   parentA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5454   parentA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5455   parentB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5456   parentB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5457
5458   parentA.SetAnchorPoint( AnchorPoint::CENTER );
5459   parentA.SetParentOrigin( ParentOrigin::CENTER );
5460
5461   parentB.SetAnchorPoint( AnchorPoint::CENTER );
5462   parentB.SetParentOrigin( ParentOrigin::CENTER );
5463
5464   stage.Add( parentA );
5465   stage.Add( parentB );
5466
5467   Actor actorA = Actor::New();
5468   Actor actorB = Actor::New();
5469   Actor actorC = Actor::New();
5470
5471   parentA.Add( actorA );
5472   parentA.Add( actorB );
5473
5474   tet_printf( "Actor C added to different parent from A and B \n" );
5475   parentB.Add( actorC );
5476
5477   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5478   actorA.SetParentOrigin( ParentOrigin::CENTER );
5479
5480   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5481   actorB.SetParentOrigin( ParentOrigin::CENTER );
5482
5483   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5484   actorC.SetParentOrigin( ParentOrigin::CENTER );
5485
5486   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5487   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5488
5489   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5490   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5491
5492   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5493   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5494
5495   ResetTouchCallbacks();
5496
5497   // Connect ChildOrderChangedSignal
5498   bool orderChangedSignal( false );
5499   Actor orderChangedActor;
5500   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5501   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5502
5503   application.SendNotification();
5504   application.Render();
5505
5506   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5507   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5508   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5509
5510   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5511   // Only top actor will get touched.
5512   actorA.TouchSignal().Connect( TestTouchCallback );
5513   actorB.TouchSignal().Connect( TestTouchCallback2 );
5514   actorC.TouchSignal().Connect( TestTouchCallback3 );
5515
5516   Dali::Integration::Point point;
5517   point.SetDeviceId( 1 );
5518   point.SetState( PointState::DOWN );
5519   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5520   Dali::Integration::TouchEvent touchEvent;
5521   touchEvent.AddPoint( point );
5522
5523   application.ProcessEvent( touchEvent );
5524
5525   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5526   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5527   DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
5528
5529   ResetTouchCallbacks();
5530
5531   tet_printf( "Raise actor A Above Actor C which have different parents\n" );
5532
5533   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5534   actorA.RaiseAbove( actorC );
5535   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5536
5537   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5538   application.SendNotification();
5539
5540   application.ProcessEvent( touchEvent ); // touch event
5541
5542   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5543   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5544   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5545
5546   ResetTouchCallbacks();
5547
5548   END_TEST;
5549 }
5550
5551 int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
5552 {
5553   tet_infoline( "UtcDaliActor Test  raiseAbove and lowerBelow api when target Actor has no parent \n" );
5554
5555   TestApplication application;
5556
5557   Stage stage( Stage::GetCurrent() );
5558
5559   Actor actorA = Actor::New();
5560   Actor actorB = Actor::New();
5561   Actor actorC = Actor::New();
5562
5563   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5564   actorA.SetParentOrigin( ParentOrigin::CENTER );
5565
5566   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5567   actorB.SetParentOrigin( ParentOrigin::CENTER );
5568
5569   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5570   actorC.SetParentOrigin( ParentOrigin::CENTER );
5571
5572   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5573   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5574
5575   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5576   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5577
5578   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5579   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5580
5581   ResetTouchCallbacks();
5582
5583   // Connect ChildOrderChangedSignal
5584   bool orderChangedSignal( false );
5585   Actor orderChangedActor;
5586   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5587   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5588
5589   application.SendNotification();
5590   application.Render();
5591
5592   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5593   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5594   DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
5595
5596   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5597   // Only top actor will get touched.
5598   actorA.TouchSignal().Connect( TestTouchCallback );
5599   actorB.TouchSignal().Connect( TestTouchCallback2 );
5600   actorC.TouchSignal().Connect( TestTouchCallback3 );
5601
5602   Dali::Integration::Point point;
5603   point.SetDeviceId( 1 );
5604   point.SetState( PointState::DOWN );
5605   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5606   Dali::Integration::TouchEvent touchEvent;
5607   touchEvent.AddPoint( point );
5608
5609   tet_printf( "Raise actor A Above Actor C which have no parents\n" );
5610
5611   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5612   actorA.RaiseAbove( actorC );
5613   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5614
5615   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5616   application.SendNotification();
5617
5618   application.ProcessEvent( touchEvent );
5619
5620   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5621
5622   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5623   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5624   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5625
5626   ResetTouchCallbacks();
5627
5628   orderChangedSignal = false;
5629
5630   stage.Add ( actorB );
5631   tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
5632
5633   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5634   actorA.LowerBelow( actorC );
5635   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5636
5637   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5638   application.SendNotification();
5639   application.Render();
5640
5641   application.ProcessEvent( touchEvent );
5642
5643   tet_printf( "Actor A not parented so LowerBelow should show no effect\n" );
5644   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5645   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5646   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5647
5648   ResetTouchCallbacks();
5649
5650   orderChangedSignal = false;
5651
5652   tet_printf( "Adding Actor A to stage, will be on top\n" );
5653
5654   stage.Add ( actorA );
5655   application.SendNotification();
5656   application.Render();
5657
5658   tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
5659
5660   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5661   actorB.RaiseAbove( actorC );
5662   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5663
5664   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5665   application.SendNotification();
5666
5667   application.ProcessEvent( touchEvent );
5668
5669   tet_printf( "C not parented so RaiseAbove should show no effect\n" );
5670   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5671   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5672   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5673
5674   ResetTouchCallbacks();
5675
5676   orderChangedSignal = false;
5677
5678   tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
5679
5680   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5681   actorA.LowerBelow( actorC );
5682   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5683
5684   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5685   application.SendNotification();
5686
5687   application.ProcessEvent( touchEvent );
5688
5689   tet_printf( "C not parented so LowerBelow should show no effect\n" );
5690   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5691   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5692   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5693
5694   ResetTouchCallbacks();
5695
5696   orderChangedSignal = false;
5697
5698   stage.Add ( actorC );
5699
5700   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5701   actorA.RaiseAbove( actorC );
5702   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5703   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5704
5705   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
5706   application.SendNotification();
5707   application.Render();
5708
5709   application.ProcessEvent( touchEvent );
5710
5711   tet_printf( "Raise actor A Above Actor C, now both have same parent \n" );
5712   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5713   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5714   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5715
5716   END_TEST;
5717 }
5718
5719 int UtcDaliActorTestAllAPIwhenActorNotParented(void)
5720 {
5721   tet_infoline( "UtcDaliActor Test all raise/lower api when actor has no parent \n" );
5722
5723   TestApplication application;
5724
5725   Stage stage( Stage::GetCurrent() );
5726
5727   Actor actorA = Actor::New();
5728   Actor actorB = Actor::New();
5729   Actor actorC = Actor::New();
5730
5731   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5732   actorA.SetParentOrigin( ParentOrigin::CENTER );
5733
5734   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5735   actorB.SetParentOrigin( ParentOrigin::CENTER );
5736
5737   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5738   actorC.SetParentOrigin( ParentOrigin::CENTER );
5739
5740   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5741   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5742
5743   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5744   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5745
5746   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5747   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5748
5749   ResetTouchCallbacks();
5750
5751   // Connect ChildOrderChangedSignal
5752   bool orderChangedSignal( false );
5753   Actor orderChangedActor;
5754   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5755   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5756
5757   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5758   // Only top actor will get touched.
5759   actorA.TouchSignal().Connect( TestTouchCallback );
5760   actorB.TouchSignal().Connect( TestTouchCallback2 );
5761   actorC.TouchSignal().Connect( TestTouchCallback3 );
5762
5763   Dali::Integration::Point point;
5764   point.SetDeviceId( 1 );
5765   point.SetState( PointState::DOWN );
5766   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5767   Dali::Integration::TouchEvent touchEvent;
5768   touchEvent.AddPoint( point );
5769
5770   stage.Add ( actorA );
5771   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
5772
5773   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5774   actorB.Raise();
5775   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5776
5777   application.SendNotification();
5778   application.Render();
5779
5780   application.ProcessEvent( touchEvent );
5781
5782   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5783
5784   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5785   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5786   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5787
5788   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
5789   ResetTouchCallbacks();
5790
5791   orderChangedSignal = false;
5792
5793   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5794   actorC.Lower();
5795   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5796
5797   // Sort actor tree before next touch event
5798   application.SendNotification();
5799   application.Render();
5800
5801   application.ProcessEvent( touchEvent );
5802
5803   tet_printf( "Not parented so RaiseAbove should show no effect\n" );
5804
5805   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5806   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5807   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5808   ResetTouchCallbacks();
5809
5810   orderChangedSignal = false;
5811
5812   tet_printf( "Lower actor C below B but C not parented\n" );
5813
5814   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5815   actorB.Lower();
5816   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5817
5818   // Sort actor tree before next touch event
5819   application.SendNotification();
5820   application.Render();
5821
5822   application.ProcessEvent( touchEvent );
5823
5824   tet_printf( "Not parented so Lower should show no effect\n" );
5825
5826   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5827   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5828   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5829   ResetTouchCallbacks();
5830
5831   orderChangedSignal = false;
5832
5833   tet_printf( "Raise actor B to top\n" );
5834
5835   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5836   actorB.RaiseToTop();
5837   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5838
5839   // Sort actor tree before next touch event
5840   application.SendNotification();
5841   application.Render();
5842
5843   application.ProcessEvent( touchEvent );
5844
5845   tet_printf( "Not parented so RaiseToTop should show no effect\n" );
5846
5847   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5848   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5849   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5850   ResetTouchCallbacks();
5851
5852   orderChangedSignal = false;
5853
5854   tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
5855
5856   stage.Add ( actorB );
5857
5858   tet_printf( "Lower actor C to Bottom, B stays at top\n" );
5859
5860   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5861   actorC.LowerToBottom();
5862   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5863
5864   application.SendNotification();
5865   application.Render();
5866
5867   application.ProcessEvent( touchEvent );
5868
5869   tet_printf( "Not parented so LowerToBottom should show no effect\n" );
5870
5871   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5872   DALI_TEST_EQUALS( gTouchCallBackCalled2,  true, TEST_LOCATION );
5873   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5874   ResetTouchCallbacks();
5875
5876   END_TEST;
5877 }
5878
5879
5880 int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
5881 {
5882   tet_infoline( "UtcDaliActor RaiseToAbove and  test with actor provided as target resulting in a no operation \n" );
5883
5884   TestApplication application;
5885
5886   Stage stage( Stage::GetCurrent() );
5887
5888   Actor actorA = Actor::New();
5889   Actor actorB = Actor::New();
5890   Actor actorC = Actor::New();
5891
5892   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5893   actorA.SetParentOrigin( ParentOrigin::CENTER );
5894
5895   actorB.SetAnchorPoint( AnchorPoint::CENTER );
5896   actorB.SetParentOrigin( ParentOrigin::CENTER );
5897
5898   actorC.SetAnchorPoint( AnchorPoint::CENTER );
5899   actorC.SetParentOrigin( ParentOrigin::CENTER );
5900
5901   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5902   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5903
5904   actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5905   actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5906
5907   actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
5908   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
5909
5910   stage.Add( actorA );
5911   stage.Add( actorB );
5912   stage.Add( actorC );
5913
5914   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
5915   // Only top actor will get touched.
5916   actorA.TouchSignal().Connect( TestTouchCallback );
5917   actorB.TouchSignal().Connect( TestTouchCallback2 );
5918   actorC.TouchSignal().Connect( TestTouchCallback3 );
5919
5920   ResetTouchCallbacks();
5921
5922   // Connect ChildOrderChangedSignal
5923   bool orderChangedSignal( false );
5924   Actor orderChangedActor;
5925   ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
5926   DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
5927
5928   application.SendNotification();
5929   application.Render();
5930
5931   Dali::Integration::Point point;
5932   point.SetDeviceId( 1 );
5933   point.SetState( PointState::DOWN );
5934   point.SetScreenPosition( Vector2( 10.f, 10.f ) );
5935   Dali::Integration::TouchEvent touchEvent;
5936   touchEvent.AddPoint( point );
5937
5938   application.ProcessEvent( touchEvent );
5939
5940   DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
5941   DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
5942   DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
5943
5944   ResetTouchCallbacks();
5945
5946   tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
5947
5948   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5949   actorA.RaiseAbove( actorA );
5950   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5951   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5952
5953   application.SendNotification();
5954   application.Render();
5955
5956   application.ProcessEvent( touchEvent );
5957
5958   tet_infoline( "No target is source Actor so RaiseAbove should show no effect\n" );
5959
5960   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
5961   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5962   DALI_TEST_EQUALS( gTouchCallBackCalled3,  true , TEST_LOCATION );
5963
5964   ResetTouchCallbacks();
5965
5966   orderChangedSignal = false;
5967
5968   DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
5969   actorA.RaiseAbove( actorC );
5970   DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
5971   DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
5972
5973   application.SendNotification();
5974   application.Render();
5975
5976   application.ProcessEvent( touchEvent );
5977
5978   tet_infoline( "Raise actor A Above Actor C which will now be successful \n" );
5979   DALI_TEST_EQUALS( gTouchCallBackCalled,  true, TEST_LOCATION );
5980   DALI_TEST_EQUALS( gTouchCallBackCalled2,  false, TEST_LOCATION );
5981   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
5982
5983   END_TEST;
5984 }
5985
5986 int UtcDaliActorGetScreenPosition(void)
5987 {
5988   tet_infoline( "UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n" );
5989
5990   TestApplication application;
5991
5992   Stage stage( Stage::GetCurrent() );
5993
5994   Actor actorA = Actor::New();
5995   actorA.SetAnchorPoint( AnchorPoint::CENTER );
5996
5997   Vector2 size2( 10.0f, 20.0f );
5998   actorA.SetSize( size2 );
5999
6000   actorA.SetPosition( 0.f, 0.f );
6001
6002   tet_infoline( "UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n" );
6003
6004   stage.Add( actorA );
6005
6006   application.SendNotification();
6007   application.Render();
6008
6009   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6010   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6011
6012   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::CENTER \n",  actorWorldPosition.x, actorWorldPosition.y  );
6013   tet_printf( "Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y );
6014
6015   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6016   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6017
6018   tet_infoline( "UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n" );
6019
6020   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6021
6022   application.SendNotification();
6023   application.Render();
6024
6025   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6026   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6027
6028   tet_printf( "Actor World Position  ( %f %f ) AnchorPoint::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y );
6029   tet_printf( "Actor Screen Position  ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y );
6030
6031   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6032   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6033
6034   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n" );
6035
6036   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6037
6038   application.SendNotification();
6039   application.Render();
6040
6041   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6042   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6043
6044   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT   \n",  actorWorldPosition.x, actorWorldPosition.y );
6045   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT  \n", actorScreenPosition.x, actorScreenPosition.y );
6046
6047   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6048   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6049
6050   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n" );
6051
6052   actorA.SetPosition( 30.0, 0.0 );
6053
6054   application.SendNotification();
6055   application.Render();
6056
6057   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6058   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6059
6060   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n",  actorWorldPosition.x, actorWorldPosition.y );
6061   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0   \n", actorScreenPosition.x, actorScreenPosition.y );
6062
6063   DALI_TEST_EQUALS( actorScreenPosition.x,  30lu , TEST_LOCATION );
6064   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6065
6066   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n" );
6067
6068   actorA.SetPosition( 30.0, 420.0 );
6069
6070   application.SendNotification();
6071   application.Render();
6072
6073   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6074   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6075
6076   DALI_TEST_EQUALS( actorScreenPosition.x,  30lu , TEST_LOCATION );
6077   DALI_TEST_EQUALS( actorScreenPosition.y,  420lu , TEST_LOCATION );
6078
6079   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n",  actorWorldPosition.x, actorWorldPosition.y );
6080   tet_printf( "Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y );
6081
6082   tet_infoline( "UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n" );
6083
6084   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6085   actorA.SetPosition( 30.0, 30.0 );
6086
6087   Actor actorB = Actor::New();
6088   actorB.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6089   actorB.SetSize( size2 );
6090   actorB.SetPosition( 10.f, 10.f );
6091   actorA.Add( actorB );
6092
6093   actorA.SetScale( 2.0f );
6094
6095   application.SendNotification();
6096   application.Render();
6097
6098   actorScreenPosition = actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6099
6100   DALI_TEST_EQUALS( actorScreenPosition.x,  50lu , TEST_LOCATION );
6101   DALI_TEST_EQUALS( actorScreenPosition.y,  50lu , TEST_LOCATION );
6102
6103   END_TEST;
6104 }
6105
6106 int UtcDaliActorGetScreenPositionAfterScaling(void)
6107 {
6108   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n" );
6109
6110   TestApplication application;
6111
6112   Stage stage( Stage::GetCurrent() );
6113
6114   Actor actorA = Actor::New();
6115   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6116
6117   Vector2 size2( 10.0f, 20.0f );
6118   actorA.SetSize( size2 );
6119   actorA.SetScale( 1.5f );
6120   actorA.SetPosition( 0.f, 0.f );
6121
6122   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n" );
6123
6124   stage.Add( actorA );
6125
6126   application.SendNotification();
6127   application.Render();
6128
6129   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6130   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6131
6132   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6133   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6134
6135   DALI_TEST_EQUALS( actorScreenPosition.x,  0lu , TEST_LOCATION );
6136   DALI_TEST_EQUALS( actorScreenPosition.y,  0lu , TEST_LOCATION );
6137
6138   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n" );
6139
6140   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6141
6142   application.SendNotification();
6143   application.Render();
6144
6145   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6146   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6147
6148   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6149   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6150
6151   DALI_TEST_EQUALS( actorScreenPosition.x , 0.0f  , TEST_LOCATION );
6152   DALI_TEST_EQUALS( actorScreenPosition.y,  0.0f , TEST_LOCATION );
6153
6154   END_TEST;
6155 }
6156
6157 int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
6158 {
6159   tet_infoline( "UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n" );
6160
6161   TestApplication application;
6162
6163   Stage stage( Stage::GetCurrent() );
6164
6165   Actor actorA = Actor::New();
6166   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6167   actorA.SetParentOrigin( ParentOrigin::CENTER );
6168   Vector2 size2( 10.0f, 20.0f );
6169   actorA.SetSize( size2 );
6170   actorA.SetPosition( 0.f, 0.f );
6171
6172   tet_infoline( " TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6173
6174   stage.Add( actorA );
6175
6176   application.SendNotification();
6177   application.Render();
6178
6179   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6180   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6181
6182   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6183   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6184
6185   DALI_TEST_EQUALS( actorScreenPosition.x,  240.0f , TEST_LOCATION );
6186   DALI_TEST_EQUALS( actorScreenPosition.y,  400.0f , TEST_LOCATION );
6187
6188   tet_infoline( " BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n" );
6189
6190   actorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
6191   actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6192
6193   application.SendNotification();
6194   application.Render();
6195
6196   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6197   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6198
6199   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
6200   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6201
6202   DALI_TEST_EQUALS( actorScreenPosition.x , 480.0f , TEST_LOCATION );
6203   DALI_TEST_EQUALS( actorScreenPosition.y,  0.0f , TEST_LOCATION );
6204
6205   END_TEST;
6206   END_TEST;
6207 }
6208
6209 int UtcDaliActorGetScreenPositionWithChildActors(void)
6210 {
6211   tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n" );
6212
6213   TestApplication application;
6214
6215   Stage stage( Stage::GetCurrent() );
6216
6217   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6218
6219   Actor actorA = Actor::New();
6220   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6221   actorA.SetParentOrigin( ParentOrigin::CENTER );
6222   Vector2 size1( 10.0f, 20.0f );
6223   actorA.SetSize( size1 );
6224   actorA.SetPosition( 0.f, 0.f );
6225
6226   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6227
6228   Actor parentActorA = Actor::New();
6229   parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6230   parentActorA.SetParentOrigin( ParentOrigin::CENTER );
6231   Vector2 size2( 30.0f, 60.0f );
6232   parentActorA.SetSize( size2 );
6233   parentActorA.SetPosition( 0.f, 0.f );
6234
6235   tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
6236
6237   stage.Add( parentActorA );
6238   parentActorA.Add ( actorA );
6239
6240   application.SendNotification();
6241   application.Render();
6242
6243   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6244   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6245
6246   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6247   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6248
6249   DALI_TEST_EQUALS( actorScreenPosition.x,  255.0f , TEST_LOCATION );
6250   DALI_TEST_EQUALS( actorScreenPosition.y,  430.0f , TEST_LOCATION );
6251
6252   tet_infoline( "Test 2\n");
6253
6254   tet_infoline( "change parent anchor point and parent origin then check screen position \n" );
6255
6256   parentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
6257   parentActorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
6258
6259   application.SendNotification();
6260   application.Render();
6261
6262   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6263   actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6264
6265   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6266   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6267
6268   DALI_TEST_EQUALS( actorScreenPosition.x,  15.0f , TEST_LOCATION );
6269   DALI_TEST_EQUALS( actorScreenPosition.y,  -30.0f , TEST_LOCATION );
6270
6271   END_TEST;
6272 }
6273
6274 int UtcDaliActorGetScreenPositionWithChildActors02(void)
6275 {
6276   tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n" );
6277
6278   TestApplication application;
6279
6280   Stage stage( Stage::GetCurrent() );
6281
6282   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6283
6284   Actor actorA = Actor::New();
6285   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6286   actorA.SetParentOrigin( ParentOrigin::CENTER );
6287   Vector2 size1( 10.0f, 20.0f );
6288   actorA.SetSize( size1 );
6289   actorA.SetPosition( 0.f, 0.f );
6290
6291   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
6292
6293   Actor parentActorA = Actor::New();
6294   parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6295   parentActorA.SetParentOrigin( ParentOrigin::CENTER );
6296   Vector2 size2( 30.0f, 60.0f );
6297   parentActorA.SetSize( size2 );
6298   parentActorA.SetPosition( 0.f, 0.f );
6299
6300   tet_infoline( "Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n" );
6301
6302   Actor grandParentActorA = Actor::New();
6303   grandParentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
6304   grandParentActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
6305   Vector2 size3( 60.0f, 120.0f );
6306   grandParentActorA.SetSize( size3 );
6307   grandParentActorA.SetPosition( 0.f, 0.f );
6308
6309   tet_infoline( "Add Parent 1 to Grand Parent 1 \n" );
6310
6311   stage.Add( grandParentActorA );
6312   grandParentActorA.Add ( parentActorA );
6313
6314   tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
6315
6316   parentActorA.Add ( actorA );
6317
6318   application.SendNotification();
6319   application.Render();
6320
6321   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
6322   Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
6323
6324   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
6325   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
6326
6327   DALI_TEST_EQUALS( actorScreenPosition.x,  45.0f , TEST_LOCATION );
6328   DALI_TEST_EQUALS( actorScreenPosition.y,  770.0f , TEST_LOCATION );
6329
6330   END_TEST;
6331 }
6332
6333 int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
6334 {
6335   tet_infoline( "UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point" );
6336
6337   TestApplication application;
6338
6339   Stage stage( Stage::GetCurrent() );
6340
6341   tet_infoline( "Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6342
6343   Actor actorA = Actor::New();
6344   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6345   actorA.SetParentOrigin( ParentOrigin::CENTER );
6346   actorA.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6347   actorA.SetSize( 10.0f, 20.0f );
6348   stage.Add( actorA );
6349
6350   tet_infoline( "Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6351
6352   Actor actorB = Actor::New();
6353   actorB.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6354   actorB.SetParentOrigin( ParentOrigin::CENTER );
6355   actorB.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6356   Vector2 actorBSize( 30.0f, 60.0f );
6357   actorB.SetSize( actorBSize );
6358   stage.Add( actorB );
6359
6360   tet_infoline( "Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
6361
6362   Actor actorC = Actor::New();
6363   actorC.SetAnchorPoint( AnchorPoint::CENTER );
6364   actorC.SetParentOrigin( ParentOrigin::CENTER );
6365   actorC.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6366   Vector2 actorCSize( 60.0f, 120.0f );
6367   actorC.SetSize( actorCSize );
6368   stage.Add( actorC );
6369
6370   application.SendNotification();
6371   application.Render();
6372
6373   tet_infoline( "Despite differing sizes and anchor-points, the screen position for all actors is the same");
6374
6375   Vector2 center( stage.GetSize() * 0.5f );
6376
6377   DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6378   DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6379   DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
6380
6381   tet_infoline( "Add scale to all actors" );
6382
6383   actorA.SetScale( 2.0f );
6384   actorB.SetScale( 2.0f );
6385   actorC.SetScale( 2.0f );
6386
6387   application.SendNotification();
6388   application.Render();
6389
6390   DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION );
6391   DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION );
6392   DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION );
6393
6394   END_TEST;
6395 }
6396
6397 int utcDaliActorPositionUsesAnchorPoint(void)
6398 {
6399   TestApplication application;
6400   tet_infoline( "Check default behaviour\n" );
6401
6402   Actor actor = Actor::New();
6403   actor.SetParentOrigin( ParentOrigin::CENTER );
6404   actor.SetAnchorPoint( AnchorPoint::CENTER );
6405   actor.SetSize( 100.0f, 100.0f );
6406   Stage::GetCurrent().Add( actor );
6407
6408   application.SendNotification();
6409   application.Render();
6410
6411   tet_infoline( "Check that the world position is in the center\n" );
6412   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
6413
6414   tet_infoline( "Set the position uses anchor point property to false\n" );
6415   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6416
6417   application.SendNotification();
6418   application.Render();
6419
6420   tet_infoline( "Check that the world position has changed appropriately\n" );
6421   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6422
6423   END_TEST;
6424 }
6425
6426 int utcDaliActorPositionUsesAnchorPointCheckScale(void)
6427 {
6428   TestApplication application;
6429   tet_infoline( "Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6430
6431   Actor actor = Actor::New();
6432   actor.SetParentOrigin( ParentOrigin::CENTER );
6433   actor.SetAnchorPoint( AnchorPoint::CENTER );
6434   actor.SetSize( 100.0f, 100.0f );
6435   actor.SetScale( 2.0f );
6436   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6437   Stage::GetCurrent().Add( actor );
6438
6439   application.SendNotification();
6440   application.Render();
6441
6442   tet_infoline( "Check the world position is the same as it would be without a scale\n" );
6443   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6444
6445   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6446   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6447   application.SendNotification();
6448   application.Render();
6449   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
6450
6451   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6452   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6453   application.SendNotification();
6454   application.Render();
6455   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
6456
6457   END_TEST;
6458 }
6459
6460 int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
6461 {
6462   TestApplication application;
6463   tet_infoline( "Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6464
6465   Actor actor = Actor::New();
6466   actor.SetParentOrigin( ParentOrigin::CENTER );
6467   actor.SetAnchorPoint( AnchorPoint::CENTER );
6468   actor.SetSize( 100.0f, 100.0f );
6469   actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
6470   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6471   Stage::GetCurrent().Add( actor );
6472
6473   application.SendNotification();
6474   application.Render();
6475
6476   tet_infoline( "Check the world position is the same as it would be without a rotation\n" );
6477   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6478
6479   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6480   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6481   application.SendNotification();
6482   application.Render();
6483   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6484
6485   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6486   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6487   application.SendNotification();
6488   application.Render();
6489   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
6490
6491   END_TEST;
6492 }
6493
6494 int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
6495 {
6496   TestApplication application;
6497   tet_infoline( "Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6498
6499   Actor actor = Actor::New();
6500   actor.SetParentOrigin( ParentOrigin::CENTER );
6501   actor.SetAnchorPoint( AnchorPoint::CENTER );
6502   actor.SetSize( 100.0f, 100.0f );
6503   actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
6504   actor.SetScale( 2.0f );
6505   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6506   Stage::GetCurrent().Add( actor );
6507
6508   application.SendNotification();
6509   application.Render();
6510
6511   tet_infoline( "Check the world position is the same as it would be without a scale and rotation\n" );
6512   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
6513
6514   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
6515   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6516   application.SendNotification();
6517   application.Render();
6518   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
6519
6520   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
6521   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6522   application.SendNotification();
6523   application.Render();
6524   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
6525
6526   END_TEST;
6527 }
6528
6529 int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
6530 {
6531   TestApplication application;
6532   tet_infoline( "Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
6533
6534   Actor parent = Actor::New();
6535
6536   Stage::GetCurrent().Add( parent );
6537   Vector2 stageSize( Stage::GetCurrent().GetSize() );
6538
6539   Actor actor = Actor::New();
6540   actor.SetParentOrigin( ParentOrigin::CENTER );
6541   actor.SetAnchorPoint( AnchorPoint::CENTER );
6542   actor.SetSize( 100.0f, 100.0f );
6543   actor.SetInheritScale( false );
6544   actor.SetInheritOrientation( false );
6545   actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
6546   parent.Add( actor );
6547
6548   application.SendNotification();
6549   application.Render();
6550
6551   const Vector3 expectedWorldPosition( -stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f );
6552
6553   tet_infoline( "Check the world position is in the right place\n" );
6554   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6555
6556   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed" );
6557   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
6558   application.SendNotification();
6559   application.Render();
6560   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6561
6562   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed" );
6563   actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
6564   application.SendNotification();
6565   application.Render();
6566   DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
6567
6568   END_TEST;
6569 }
6570
6571 int utcDaliActorVisibilityChangeSignalSelf(void)
6572 {
6573   TestApplication application;
6574   tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
6575
6576   Actor actor = Actor::New();
6577
6578   VisibilityChangedFunctorData data;
6579   DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
6580
6581   actor.SetVisible( false );
6582
6583   data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6584
6585   tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
6586   data.Reset();
6587
6588   actor.SetVisible( false );
6589   data.Check( false /* not called */, TEST_LOCATION );
6590
6591   tet_infoline( "Change the visibility using properties, ensure called" );
6592   data.Reset();
6593
6594   actor.SetProperty( Actor::Property::VISIBLE, true );
6595   data.Check( true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6596
6597   tet_infoline( "Set the visibility to current using properties, ensure not called" );
6598   data.Reset();
6599
6600   actor.SetProperty( Actor::Property::VISIBLE, true );
6601   data.Check( false /* not called */, TEST_LOCATION );
6602
6603   END_TEST;
6604 }
6605
6606 int utcDaliActorVisibilityChangeSignalChildren(void)
6607 {
6608   TestApplication application;
6609   tet_infoline( "Check that the visibility change signal is called for the children when the visibility changes for the parent" );
6610
6611   Actor parent = Actor::New();
6612   Actor child = Actor::New();
6613   parent.Add( child );
6614
6615   Actor grandChild = Actor::New();
6616   child.Add( grandChild );
6617
6618   VisibilityChangedFunctorData parentData;
6619   VisibilityChangedFunctorData childData;
6620   VisibilityChangedFunctorData grandChildData;
6621
6622   tet_infoline( "Only connect the child and grandchild, ensure they are called and not the parent" );
6623   DevelActor::VisibilityChangedSignal( child ).Connect( &application, VisibilityChangedFunctor( childData ) );
6624   DevelActor::VisibilityChangedSignal( grandChild ).Connect( &application, VisibilityChangedFunctor( grandChildData ) );
6625
6626   parent.SetVisible( false );
6627   parentData.Check( false /* not called */, TEST_LOCATION );
6628   childData.Check( true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6629   grandChildData.Check( true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6630
6631   tet_infoline( "Connect to the parent's signal as well and ensure all three are called" );
6632   parentData.Reset();
6633   childData.Reset();
6634   grandChildData.Reset();
6635
6636   DevelActor::VisibilityChangedSignal( parent ).Connect( &application, VisibilityChangedFunctor( parentData ) );
6637
6638   parent.SetVisible( true );
6639   parentData.Check( true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6640   childData.Check( true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6641   grandChildData.Check( true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
6642
6643   tet_infoline( "Ensure none of the functors are called if we attempt to change the visibility to what it already is at" );
6644   parentData.Reset();
6645   childData.Reset();
6646   grandChildData.Reset();
6647
6648   parent.SetVisible( true );
6649   parentData.Check( false /* not called */, TEST_LOCATION );
6650   childData.Check( false /* not called */, TEST_LOCATION );
6651   grandChildData.Check( false /* not called */, TEST_LOCATION );
6652
6653   END_TEST;
6654 }
6655
6656 int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
6657 {
6658   TestApplication application;
6659   tet_infoline( "Check that the visibility change signal is emitted when the visibility changes when an animation starts" );
6660
6661   Actor actor = Actor::New();
6662   Stage::GetCurrent().Add( actor );
6663
6664   application.SendNotification();
6665   application.Render();
6666
6667   VisibilityChangedFunctorData data;
6668   DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
6669
6670   Animation animation = Animation::New( 1.0f );
6671   animation.AnimateTo( Property( actor, Actor::Property::VISIBLE ), false );
6672
6673   data.Check( false, TEST_LOCATION );
6674   DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6675   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6676
6677   tet_infoline( "Play the animation and check the property value" );
6678   animation.Play();
6679
6680   data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
6681   DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
6682
6683   tet_infoline( "Animation not currently finished, so the current visibility should still be true" );
6684   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
6685
6686   application.SendNotification();
6687   application.Render( 1100 ); // After the animation
6688
6689   DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
6690
6691   END_TEST;
6692 }
6693
6694
6695 int utcDaliActorVisibilityChangeSignalByName(void)
6696 {
6697   TestApplication application;
6698   tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
6699
6700   Actor actor = Actor::New();
6701
6702   bool signalCalled=false;
6703   actor.ConnectSignal( &application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled) );
6704   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6705   actor.SetVisible( false );
6706   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6707
6708   tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
6709   signalCalled = false;
6710   actor.SetVisible( false );
6711   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6712
6713   tet_infoline( "Change the visibility using properties, ensure called" );
6714   actor.SetProperty( Actor::Property::VISIBLE, true );
6715   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6716
6717   tet_infoline( "Set the visibility to current using properties, ensure not called" );
6718   signalCalled = false;
6719
6720   actor.SetProperty( Actor::Property::VISIBLE, true );
6721   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6722
6723   END_TEST;
6724 }
6725
6726
6727 static void LayoutDirectionChanged( Actor actor, LayoutDirection::Type type )
6728 {
6729   gLayoutDirectionType = type;
6730 }
6731
6732 int UtcDaliActorLayoutDirectionProperty(void)
6733 {
6734   TestApplication application;
6735   tet_infoline( "Check layout direction property" );
6736
6737   Actor actor0 = Actor::New();
6738   DALI_TEST_EQUALS( actor0.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6739   Stage::GetCurrent().Add( actor0 );
6740
6741   application.SendNotification();
6742   application.Render();
6743
6744   Actor actor1 = Actor::New();
6745   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6746   Actor actor2 = Actor::New();
6747   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6748   Actor actor3 = Actor::New();
6749   DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6750   Actor actor4 = Actor::New();
6751   DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6752   Actor actor5 = Actor::New();
6753   DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6754   Actor actor6 = Actor::New();
6755   DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6756   Actor actor7 = Actor::New();
6757   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6758   Actor actor8 = Actor::New();
6759   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6760   Actor actor9 = Actor::New();
6761   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6762
6763   actor1.Add( actor2 );
6764   gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
6765   actor2.LayoutDirectionChangedSignal().Connect( LayoutDirectionChanged );
6766
6767   DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
6768   actor1.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6769   DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
6770
6771   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6772   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6773   DALI_TEST_EQUALS( gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION );
6774
6775   actor1.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
6776   actor0.Add( actor1 );
6777   DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6778   DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6779
6780   Stage::GetCurrent().Add( actor3 );
6781   actor3.Add( actor4 );
6782   actor4.Add( actor5 );
6783   actor5.Add( actor6 );
6784   actor5.Add( actor7 );
6785   actor7.Add( actor8 );
6786   actor8.Add( actor9 );
6787   actor3.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6788   actor5.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6789
6790   DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
6791   actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, false );
6792   DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
6793
6794   actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6795
6796   DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6797   DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6798   DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6799   DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6800   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6801   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6802   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6803
6804   actor8.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
6805   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6806   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6807
6808   actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6809   DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6810   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6811   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
6812
6813   actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
6814   DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6815   DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6816
6817   END_TEST;
6818 }
6819
6820
6821 struct LayoutDirectionFunctor
6822 {
6823   LayoutDirectionFunctor(bool& signalCalled)
6824   : mSignalCalled( signalCalled )
6825   {
6826   }
6827
6828   LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
6829   : mSignalCalled( rhs.mSignalCalled )
6830   {
6831   }
6832
6833   void operator()()
6834   {
6835     mSignalCalled = true;
6836   }
6837
6838   bool& mSignalCalled;
6839 };
6840
6841 int UtcDaliActorLayoutDirectionSignal(void)
6842 {
6843   TestApplication application;
6844   tet_infoline( "Check changing layout direction property sends a signal" );
6845
6846   Actor actor = Actor::New();
6847   DALI_TEST_EQUALS( actor.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
6848   Stage::GetCurrent().Add( actor );
6849   bool signalCalled = false;
6850   LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
6851
6852   actor.ConnectSignal( &application, "layoutDirectionChanged", layoutDirectionFunctor );
6853   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6854
6855   // Test that writing the same value doesn't send a signal
6856   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
6857   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6858
6859   // Test that writing a different value sends the signal
6860   signalCalled = false;
6861   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6862   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
6863
6864   signalCalled = false;
6865   actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
6866   DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
6867
6868   END_TEST;
6869 }
6870
6871 struct ChildAddedSignalCheck
6872 {
6873   ChildAddedSignalCheck( bool& signalReceived, Actor& childHandle )
6874   : mSignalReceived( signalReceived ),
6875     mChildHandle( childHandle )
6876   {
6877   }
6878
6879   void operator() ( Actor childHandle )
6880   {
6881     mSignalReceived = true;
6882     mChildHandle = childHandle;
6883   }
6884   void operator() ()
6885   {
6886     mSignalReceived = true;
6887     mChildHandle = Actor();
6888   }
6889
6890   bool& mSignalReceived;
6891   Actor& mChildHandle;
6892 };
6893
6894 int UtcDaliChildAddedSignalP1(void)
6895 {
6896   TestApplication application;
6897   auto stage = Stage::GetCurrent();
6898
6899   bool signalReceived=false;
6900   Actor childActor;
6901
6902   ChildAddedSignalCheck signal( signalReceived, childActor );
6903   DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
6904   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6905
6906   auto actorA = Actor::New();
6907   stage.Add( actorA );
6908   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6909   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
6910   signalReceived = false;
6911
6912   auto actorB = Actor::New();
6913   stage.Add( actorB );
6914   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6915   DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
6916
6917   END_TEST;
6918 }
6919
6920
6921 int UtcDaliChildAddedSignalP2(void)
6922 {
6923   TestApplication application;
6924   auto stage = Stage::GetCurrent();
6925
6926   bool signalReceived=false;
6927   Actor childActor;
6928
6929   ChildAddedSignalCheck signal( signalReceived, childActor );
6930   tet_infoline( "Connect to childAdded signal by name" );
6931
6932   stage.GetRootLayer().ConnectSignal( &application, "childAdded", signal );
6933   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6934
6935   auto actorA = Actor::New();
6936   stage.Add( actorA );
6937   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6938
6939   // Can't test which actor was added; signal signature is void() when connecting via name.
6940   signalReceived = false;
6941
6942   auto actorB = Actor::New();
6943   stage.Add( actorB );
6944   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6945
6946   END_TEST;
6947 }
6948
6949 int UtcDaliChildAddedSignalN(void)
6950 {
6951   TestApplication application;
6952   auto stage = Stage::GetCurrent();
6953
6954   bool signalReceived=false;
6955   Actor childActor;
6956
6957   ChildAddedSignalCheck signal( signalReceived, childActor );
6958   DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
6959   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6960
6961   auto actorA = Actor::New();
6962   stage.Add( actorA );
6963   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
6964   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
6965   signalReceived = false;
6966
6967   auto actorB = Actor::New();
6968   actorA.Add( actorB );
6969   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
6970   END_TEST;
6971 }
6972
6973
6974 struct ChildRemovedSignalCheck
6975 {
6976   ChildRemovedSignalCheck( bool& signalReceived, Actor& childHandle )
6977   : mSignalReceived( signalReceived ),
6978     mChildHandle( childHandle )
6979   {
6980   }
6981
6982   void operator() ( Actor childHandle )
6983   {
6984     mSignalReceived = true;
6985     mChildHandle = childHandle;
6986   }
6987
6988   void operator() ()
6989   {
6990     mSignalReceived = true;
6991   }
6992
6993   bool& mSignalReceived;
6994   Actor& mChildHandle;
6995 };
6996
6997 int UtcDaliChildRemovedSignalP1(void)
6998 {
6999   TestApplication application;
7000   auto stage = Stage::GetCurrent();
7001
7002   bool signalReceived=false;
7003   Actor childActor;
7004
7005   ChildRemovedSignalCheck signal( signalReceived, childActor );
7006   DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
7007   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7008
7009   auto actorA = Actor::New();
7010   stage.Add( actorA );
7011   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7012   DALI_TEST_CHECK( !childActor );
7013
7014   stage.Remove( actorA );
7015   DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
7016   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7017
7018   signalReceived = false;
7019   auto actorB = Actor::New();
7020   stage.Add( actorB );
7021   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7022
7023   stage.Remove( actorB );
7024   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7025   DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
7026
7027   END_TEST;
7028 }
7029
7030 int UtcDaliChildRemovedSignalP2(void)
7031 {
7032   TestApplication application;
7033   auto stage = Stage::GetCurrent();
7034
7035   bool signalReceived=false;
7036   Actor childActor;
7037
7038   ChildAddedSignalCheck signal( signalReceived, childActor );
7039   tet_infoline( "Connect to childRemoved signal by name" );
7040
7041   stage.GetRootLayer().ConnectSignal( &application, "childRemoved", signal );
7042   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7043
7044   auto actorA = Actor::New();
7045   stage.Add( actorA );
7046   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7047
7048   stage.Remove( actorA );
7049   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7050
7051   signalReceived = false;
7052   auto actorB = Actor::New();
7053   stage.Add( actorB );
7054   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7055
7056   stage.Remove( actorB );
7057   DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
7058
7059   END_TEST;
7060 }
7061
7062
7063 int UtcDaliChildRemovedSignalN(void)
7064 {
7065   TestApplication application;
7066   auto stage = Stage::GetCurrent();
7067
7068   bool signalReceived=false;
7069   Actor childActor;
7070
7071   ChildRemovedSignalCheck signal( signalReceived, childActor );
7072   DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
7073   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7074
7075   auto actorA = Actor::New();
7076   stage.Add( actorA );
7077
7078   auto actorB = Actor::New();
7079   actorA.Add( actorB );
7080
7081   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7082   DALI_TEST_CHECK( ! childActor );
7083
7084   actorA.Remove( actorB );
7085   DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
7086   END_TEST;
7087 }
7088
7089
7090 int UtcDaliChildMovedSignalP(void)
7091 {
7092   TestApplication application;
7093   auto stage = Stage::GetCurrent();
7094
7095   bool addedASignalReceived   = false;
7096   bool removedASignalReceived = false;
7097   bool addedBSignalReceived   = false;
7098   bool removedBSignalReceived = false;
7099   Actor childActor;
7100
7101   auto actorA = Actor::New();
7102   auto actorB = Actor::New();
7103   stage.Add( actorA );
7104   stage.Add( actorB );
7105
7106   ChildAddedSignalCheck addedSignalA( addedASignalReceived, childActor );
7107   ChildRemovedSignalCheck removedSignalA( removedASignalReceived, childActor );
7108   ChildAddedSignalCheck addedSignalB( addedBSignalReceived, childActor );
7109   ChildRemovedSignalCheck removedSignalB( removedBSignalReceived, childActor );
7110
7111   DevelActor::ChildAddedSignal( actorA ).Connect( &application, addedSignalA );
7112   DevelActor::ChildRemovedSignal( actorA ).Connect( &application, removedSignalA );
7113   DevelActor::ChildAddedSignal( actorB ).Connect( &application, addedSignalB );
7114   DevelActor::ChildRemovedSignal( actorB ).Connect( &application, removedSignalB );
7115
7116   DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
7117   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7118   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7119   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7120
7121   // Create a child of A
7122
7123   auto child = Actor::New();
7124   actorA.Add( child );
7125
7126   DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
7127   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7128   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7129   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7130   DALI_TEST_EQUALS( childActor, child, TEST_LOCATION );
7131
7132   // Move child to B:
7133   addedASignalReceived   = false;
7134   addedBSignalReceived   = false;
7135   removedASignalReceived = false;
7136   removedBSignalReceived = false;
7137
7138   actorB.Add( child ); // Expect this child to be re-parented
7139   DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
7140   DALI_TEST_EQUALS( removedASignalReceived, true, TEST_LOCATION );
7141   DALI_TEST_EQUALS( addedBSignalReceived, true, TEST_LOCATION );
7142   DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
7143
7144   // Move child back to A:
7145   addedASignalReceived   = false;
7146   addedBSignalReceived   = false;
7147   removedASignalReceived = false;
7148   removedBSignalReceived = false;
7149
7150   actorA.Add( child ); // Expect this child to be re-parented
7151   DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
7152   DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
7153   DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
7154   DALI_TEST_EQUALS( removedBSignalReceived, true, TEST_LOCATION );
7155
7156
7157   END_TEST;
7158 }
7159
7160 int utcDaliActorCulled(void)
7161 {
7162   TestApplication application;
7163   auto stage = Stage::GetCurrent();
7164
7165   tet_infoline( "Check that the actor is culled if the actor is out of the screen" );
7166
7167   Actor actor = Actor::New();
7168   actor.SetSize( 10.0f, 10.0f );
7169
7170   Geometry geometry = CreateQuadGeometry();
7171   Shader shader = CreateShader();
7172   Renderer renderer = Renderer::New(geometry, shader);
7173   actor.AddRenderer( renderer );
7174
7175   stage.Add( actor );
7176
7177   application.SendNotification();
7178   application.Render( 0 );
7179
7180   DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), false, TEST_LOCATION );
7181
7182   PropertyNotification notification = actor.AddPropertyNotification( DevelActor::Property::CULLED, LessThanCondition( 0.5f ) );
7183   notification.SetNotifyMode( PropertyNotification::NotifyOnChanged );
7184
7185   // Connect NotifySignal
7186   bool propertyNotificationSignal( false );
7187   PropertyNotification source;
7188   CulledPropertyNotificationFunctor f( propertyNotificationSignal, source );
7189   notification.NotifySignal().Connect( &application, f ) ;
7190
7191   actor.SetPosition( 1000.0f, 1000.0f );
7192
7193   application.SendNotification();
7194   application.Render();
7195
7196   application.SendNotification();
7197
7198   DALI_TEST_EQUALS( actor.GetProperty< bool >( DevelActor::Property::CULLED ), true, TEST_LOCATION );
7199
7200   DALI_TEST_EQUALS( propertyNotificationSignal, true, TEST_LOCATION );
7201   DALI_TEST_EQUALS( source.GetTargetProperty(), static_cast< int >( DevelActor::Property::CULLED ), TEST_LOCATION );
7202   DALI_TEST_EQUALS( source.GetTarget().GetProperty< bool >( source.GetTargetProperty() ), true, TEST_LOCATION );
7203
7204   END_TEST;
7205 }
7206
7207 int UtcDaliActorUpdateSizeHint(void)
7208 {
7209   TestApplication application;
7210
7211   Actor actor = Actor::New();
7212   Vector3 vector(100.0f, 100.0f, 0.0f);
7213
7214   DALI_TEST_CHECK(vector != actor.GetCurrentSize());
7215
7216   actor.SetSize(vector.x, vector.y);
7217
7218
7219   Vector2 updateSizeHint = Vector2(150.f, 150.f);
7220   actor.SetProperty(Dali::DevelActor::Property::UPDATE_SIZE_HINT, updateSizeHint);
7221
7222   // Flush the queue and render once
7223   application.SendNotification();
7224   application.Render();
7225
7226
7227   Vector2 currentSizeHint = actor.GetProperty( Dali::DevelActor::Property::UPDATE_SIZE_HINT ).Get< Vector2 >();
7228   DALI_TEST_EQUALS( currentSizeHint, updateSizeHint, Math::MACHINE_EPSILON_0, TEST_LOCATION );
7229
7230   // Flush the queue and render once
7231   application.SendNotification();
7232   application.Render();
7233
7234   END_TEST;
7235 }
7236
7237 int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
7238 {
7239   TestApplication application;
7240   auto stage = Stage::GetCurrent();
7241
7242   tet_infoline( "Ensure we clear the screen when the last actor is removed" );
7243
7244   Actor actor = CreateRenderableActor();
7245   actor.SetSize( 100.0f, 100.0f );
7246   stage.Add( actor );
7247
7248   application.SendNotification();
7249   application.Render();
7250
7251   auto& glAbstraction = application.GetGlAbstraction();
7252   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7253
7254   actor.Unparent();
7255
7256   application.SendNotification();
7257   application.Render();
7258
7259   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
7260
7261   END_TEST;
7262 }
7263
7264 int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
7265 {
7266   TestApplication application;
7267   auto stage = Stage::GetCurrent();
7268
7269   tet_infoline( "Ensure we clear the screen when the last actor is made invisible" );
7270
7271   Actor actor = CreateRenderableActor();
7272   actor.SetSize( 100.0f, 100.0f );
7273   stage.Add( actor );
7274
7275   application.SendNotification();
7276   application.Render();
7277
7278   auto& glAbstraction = application.GetGlAbstraction();
7279   const auto clearCountBefore = glAbstraction.GetClearCountCalled();
7280
7281   actor.SetVisible( false );
7282
7283   application.SendNotification();
7284   application.Render();
7285
7286   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
7287
7288   END_TEST;
7289 }