automated-tests/src/dali-toolkit/utc-Dali-ControlWrapper.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19 #include <stdlib.h>
  20
  21 // Need to override adaptor classes for toolkit test harness, so include
  22 // test harness headers before dali headers.
  23 #include <dali-toolkit-test-suite-utils.h>
  24
  25 #include <dali.h>
  26 #include <dali/public-api/dali-core.h>
  27 #include <dali/devel-api/actors/custom-actor-devel.h>
  28 #include <dali/devel-api/object/csharp-type-registry.h>
  29 #include <dali-toolkit/dali-toolkit.h>
  30 #include <dali-toolkit/devel-api/controls/control-devel.h>
  31 #include <dali-toolkit/devel-api/controls/control-wrapper.h>
  32 #include <dali-toolkit/devel-api/controls/control-wrapper-impl.h>
  33 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  34 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  35
  36 using namespace Dali;
  37 using namespace Dali::Toolkit;
  38
  39 void utc_dali_toolkit_control_wrapper_startup(void)
  40 {
  41   test_return_value = TET_UNDEF;
  42 }
  43
  44 void utc_dali_toolkit_control_wrapper_cleanup(void)
  45 {
  46   test_return_value = TET_PASS;
  47 }
  48
  49 ///////////////////////////////////////////////////////////////////////////////////////////////////
  50
  51 namespace
  52 {
  53 bool gOnRelayout = false;
  54
  55 static bool gKeyInputFocusCallBackCalled;
  56
  57 static void TestKeyInputFocusCallback( Control control )
  58 {
  59   tet_infoline(" TestKeyInputFocusCallback");
  60
  61   gKeyInputFocusCallBackCalled = true;
  62 }
  63 } // namespace
  64
  65 ///////////////////////////////////////////////////////////////////////////////////////////////////
  66
  67
  68 namespace Impl
  69 {
  70 struct TestCustomControl : public Toolkit::Internal::ControlWrapper
  71 {
  72   /**
  73    * Constructor
  74    */
  75   TestCustomControl()  : Toolkit::Internal::ControlWrapper( CustomControlBehaviour( Toolkit::Internal::ControlWrapper::DISABLE_STYLE_CHANGE_SIGNALS |
  76           Toolkit::Internal::ControlWrapper::REQUIRES_KEYBOARD_NAVIGATION_SUPPORT )) ,
  77           mDaliProperty( Property::INVALID_INDEX ),
  78           mSizeSet( Vector3::ZERO ),
  79           mTargetSize( Vector3::ZERO ),
  80           mNego( false ),
  81           mDepth( 0u )
  82   {
  83   }
  84
  85   TestCustomControl(bool nego)  : Toolkit::Internal::ControlWrapper( CustomControlBehaviour( Toolkit::Internal::ControlWrapper::DISABLE_STYLE_CHANGE_SIGNALS |
  86           Toolkit::Internal::ControlWrapper::REQUIRES_KEYBOARD_NAVIGATION_SUPPORT ) ),
  87           mDaliProperty( Property::INVALID_INDEX ),
  88           mSizeSet( Vector3::ZERO ),
  89           mTargetSize( Vector3::ZERO ),
  90           mNego( nego ),
  91           mDepth( 0u )
  92   {
  93   }
  94
  95   /**
  96    * Destructor
  97    */
  98   virtual ~TestCustomControl()
  99   {
 100   }
 101
 102   void Initialize( const char* name = NULL )
 103   {
 104     mDaliProperty = Self().RegisterProperty( "Dali", std::string("no"), Property::READ_WRITE );
 105
 106     OnInitialize( name );
 107   }
 108
 109   using Control::OnInitialize; ///< To tell the compiler that we really do want to overload OnInitialize in this class & were not trying to override it
 110   virtual void OnInitialize( const char* name ) {}
 111
 112   // From Toolkit::Internal::ControlWrapper
 113   virtual void OnSceneConnection( int depth )
 114   {
 115     mDepth = depth;
 116     Control::OnSceneConnection(depth);
 117   }
 118   virtual void OnSceneDisconnection()
 119   {
 120     Control::OnSceneDisconnection();
 121   }
 122   virtual void OnChildAdd( Actor& child )
 123   {
 124     Control::OnChildAdd(child);
 125   }
 126   virtual void OnChildRemove( Actor& child )
 127   {
 128     Control::OnChildRemove(child);
 129   }
 130   virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue )
 131   {
 132     Control::OnPropertySet(index, propertyValue);
 133   }
 134   virtual void OnSizeSet( const Vector3& targetSize )
 135   {
 136     mSizeSet = targetSize;
 137     Control::OnSizeSet( targetSize );
 138   }
 139   virtual void OnSizeAnimation( Animation& animation, const Vector3& targetSize )
 140   {
 141     mTargetSize = targetSize;
 142     Control::OnSizeAnimation( animation, targetSize );
 143   }
 144   virtual bool OnHoverEvent( const HoverEvent& event )
 145   {
 146     return true;
 147   }
 148   virtual bool OnWheelEvent( const WheelEvent& event )
 149   {
 150     return true;
 151   }
 152   virtual bool OnKeyEvent( const KeyEvent& event )
 153   {
 154     return true;
 155   }
 156   virtual void OnKeyInputFocusGained()
 157   {
 158   }
 159   virtual void OnKeyInputFocusLost()
 160   {
 161   }
 162   virtual Vector3 GetNaturalSize()
 163   {
 164     return Vector3( 0.0f, 0.0f, 0.0f );
 165   }
 166
 167   virtual float GetHeightForWidth( float width )
 168   {
 169     return 0.0f;
 170   }
 171
 172   virtual float GetWidthForHeight( float height )
 173   {
 174     return 0.0f;
 175   }
 176
 177   void TestRegisterVisual( Property::Index index, Toolkit::Visual::Base visual )
 178   {
 179     ControlWrapper::RegisterVisual( index, visual );
 180
 181     VisualIndices::iterator iter = std::find( mRegisteredVisualIndices.begin(), mRegisteredVisualIndices.end(), index );
 182     if( iter == mRegisteredVisualIndices.end() )
 183     {
 184       mRegisteredVisualIndices.push_back(index);
 185     }
 186   }
 187
 188   virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
 189   {
 190     gOnRelayout = true;
 191
 192     for( VisualIndices::iterator iter = mRegisteredVisualIndices.begin(); iter != mRegisteredVisualIndices.end() ; ++iter )
 193     {
 194       Visual::Base visual = GetVisual(*iter);
 195       Property::Map map; // empty map enforces defaults
 196       visual.SetTransformAndSize( map, size );
 197     }
 198   }
 199
 200   virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
 201   {
 202   }
 203
 204   virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
 205   {
 206   }
 207
 208   virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
 209   {
 210     return 0.0f;
 211   }
 212
 213   virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
 214   {
 215   }
 216
 217   virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
 218   {
 219     return false;
 220   }
 221
 222   void SetDaliProperty(std::string s)
 223   {
 224     Self().SetProperty(mDaliProperty, s);
 225   }
 226   void TestRelayoutRequest()
 227   {
 228     RelayoutRequest();
 229   }
 230
 231   float TestGetHeightForWidthBase( float width )
 232   {
 233     return GetHeightForWidthBase( width );
 234   }
 235
 236   float TestGetWidthForHeightBase( float height )
 237   {
 238     return GetWidthForHeightBase( height );
 239   }
 240
 241   float TestCalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
 242   {
 243     return CalculateChildSizeBase( child, dimension );
 244   }
 245
 246   bool TestRelayoutDependentOnChildrenBase( Dimension::Type dimension )
 247   {
 248     return RelayoutDependentOnChildrenBase( dimension );
 249   }
 250
 251   Property::Index mDaliProperty;
 252   Vector3 mSizeSet;
 253   Vector3 mTargetSize;
 254   bool mNego;
 255   unsigned int mDepth;
 256
 257   typedef std::vector<Property::Index> VisualIndices;
 258   VisualIndices mRegisteredVisualIndices;
 259 };
 260
 261
 262
 263 }
 264
 265 static std::string customControlTypeName = "MyTestCustomControl";
 266 static TypeRegistration customControl( customControlTypeName, typeid(Dali::Toolkit::Control), NULL );
 267
 268
 269 int UtcDaliControlWrapperConstructor(void)
 270 {
 271   ToolkitTestApplication application;  // Exceptions require ToolkitTestApplication
 272
 273   Toolkit::Internal::ControlWrapper* controlWrapperImpl = new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 274   ControlWrapper controlWrapper;
 275
 276   DALI_TEST_CHECK( !ControlWrapper::DownCast( controlWrapper ) );
 277
 278   controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 279
 280   DALI_TEST_CHECK( ControlWrapper::DownCast( controlWrapper ) );
 281
 282   Dali::TypeInfo typeInfo = DevelCustomActor::GetTypeInfo( controlWrapper );
 283
 284   DALI_TEST_EQUALS( typeInfo.GetName(), customControlTypeName, TEST_LOCATION);
 285
 286
 287   END_TEST;
 288 }
 289
 290 int UtcDaliControlWrapperDestructor(void)
 291 {
 292   TestApplication application;
 293
 294   ControlWrapper control = ControlWrapper::New( customControlTypeName, *( new Toolkit::Internal::ControlWrapper( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT ) ) );
 295
 296   ControlWrapper control2( control );
 297
 298   DALI_TEST_CHECK( control );
 299   control.Reset();
 300   DALI_TEST_CHECK( !control );
 301
 302   DALI_TEST_CHECK( control2 );
 303   control2.Reset();
 304   DALI_TEST_CHECK( !control2 );
 305
 306   END_TEST;
 307 }
 308
 309 int UtcDaliControlWrapperRelayoutRequest(void)
 310 {
 311   TestApplication application;
 312
 313   DALI_TEST_EQUALS( gOnRelayout, false, TEST_LOCATION );
 314
 315   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 316   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 317
 318   application.GetScene().Add( controlWrapper );
 319
 320   application.SendNotification();
 321   application.Render();
 322
 323   DALI_TEST_EQUALS( gOnRelayout, true, TEST_LOCATION );
 324   gOnRelayout = false;
 325
 326   controlWrapperImpl->TestRelayoutRequest();
 327   application.SendNotification();
 328   application.Render();
 329
 330   DALI_TEST_EQUALS( gOnRelayout, true, TEST_LOCATION );
 331
 332   END_TEST;
 333 }
 334
 335 int UtcDaliControlWrapperImplGetHeightForWidthBase(void)
 336 {
 337   TestApplication application;
 338
 339   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 340   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 341
 342   float width = 300.0f;
 343   float v = 0.0f;
 344
 345   application.SendNotification();
 346   application.Render();
 347
 348   v = controlWrapperImpl->TestGetHeightForWidthBase( width );
 349
 350   DALI_TEST_EQUALS( width, v, TEST_LOCATION );
 351
 352   END_TEST;
 353 }
 354
 355 int UtcDaliControlWrapperGetWidthForHeightBase(void)
 356 {
 357   TestApplication application;
 358
 359   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 360   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 361
 362   float height = 300.0f;
 363   float v = 0.0f;
 364
 365   application.SendNotification();
 366   application.Render();
 367
 368   v = controlWrapperImpl->TestGetWidthForHeightBase( height );
 369
 370   DALI_TEST_EQUALS( height, v, TEST_LOCATION );
 371
 372   END_TEST;
 373 }
 374
 375 int UtcDaliControlWrapperCalculateChildSizeBase(void)
 376 {
 377   TestApplication application;
 378
 379   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 380   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 381
 382   Actor child = Actor::New();
 383   child.SetResizePolicy( Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS );
 384   child.SetProperty( Actor::Property::SIZE, Vector2(150, 150) );
 385
 386   application.SendNotification();
 387   application.Render();
 388
 389   float v = 9.99f;
 390   v = controlWrapperImpl->TestCalculateChildSizeBase( child, Dali::Dimension::ALL_DIMENSIONS );
 391   DALI_TEST_EQUALS( v, 0.0f, TEST_LOCATION );
 392
 393   END_TEST;
 394 }
 395
 396 int UtcDaliControlWrapperRelayoutDependentOnChildrenBase(void)
 397 {
 398   TestApplication application;
 399
 400   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 401   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 402
 403   bool v = false;
 404
 405   v = controlWrapperImpl->TestRelayoutDependentOnChildrenBase( Dali::Dimension::ALL_DIMENSIONS );
 406   application.SendNotification();
 407   application.Render();
 408
 409   DALI_TEST_EQUALS( v, true, TEST_LOCATION );
 410
 411   controlWrapper.SetResizePolicy( Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS );
 412   v = controlWrapperImpl->TestRelayoutDependentOnChildrenBase( Dali::Dimension::WIDTH );
 413   application.SendNotification();
 414   application.Render();
 415   DALI_TEST_EQUALS( v, false, TEST_LOCATION );
 416
 417   END_TEST;
 418 }
 419
 420 int UtcDaliControlWrapperRegisterVisualToSelf(void)
 421 {
 422   ToolkitTestApplication application;
 423
 424   Test::ObjectDestructionTracker objectDestructionTracker( application.GetCore().GetObjectRegistry() );
 425
 426   {
 427     Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 428     ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 429
 430     objectDestructionTracker.Start( controlWrapper );
 431
 432     Property::Index index = 1;
 433
 434     Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 435     Toolkit::Visual::Base visual;
 436
 437     Property::Map map;
 438     map[Visual::Property::TYPE] = Visual::COLOR;
 439     map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 440
 441     visual = visualFactory.CreateVisual( map );
 442     DALI_TEST_CHECK( visual );
 443
 444     // Register to self
 445     controlWrapperImpl->RegisterVisual( index, visual );
 446
 447     DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), false, TEST_LOCATION ); // Control not destroyed yet
 448     DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION );
 449   }
 450
 451   DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), true, TEST_LOCATION ); // Should be destroyed
 452
 453   END_TEST;
 454 }
 455
 456 int UtcDaliControlWrapperRegisterVisualWithDepthIndexToSelf(void)
 457 {
 458   ToolkitTestApplication application;
 459
 460   Test::ObjectDestructionTracker objectDestructionTracker( application.GetCore().GetObjectRegistry() );
 461
 462   {
 463     Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 464     ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 465
 466     objectDestructionTracker.Start( controlWrapper );
 467
 468     Property::Index index = 1;
 469
 470     Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 471     Toolkit::Visual::Base visual;
 472
 473     Property::Map map;
 474     map[Visual::Property::TYPE] = Visual::COLOR;
 475     map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 476
 477     visual = visualFactory.CreateVisual( map );
 478     DALI_TEST_CHECK( visual );
 479
 480     // Register to self
 481     controlWrapperImpl->RegisterVisual( index, visual, 4 );
 482
 483     DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), false, TEST_LOCATION ); // Control not destroyed yet
 484     DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION );
 485     DALI_TEST_EQUALS( visual.GetDepthIndex(), 4, TEST_LOCATION );
 486   }
 487
 488   DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), true, TEST_LOCATION ); // Should be destroyed
 489
 490   END_TEST;
 491 }
 492
 493 int UtcDaliControlWrapperRegisterDisabledVisual(void)
 494 {
 495   ToolkitTestApplication application;
 496
 497   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 498   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 499
 500   Property::Index TEST_PROPERTY = 1;
 501
 502   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 503   Toolkit::Visual::Base visual;
 504
 505   Property::Map map;
 506   map[Visual::Property::TYPE] = Visual::COLOR;
 507   map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 508
 509   visual = visualFactory.CreateVisual( map );
 510   DALI_TEST_CHECK(visual);
 511
 512   // Register index with a color visual
 513   controlWrapperImpl->RegisterVisual( TEST_PROPERTY, visual, false );
 514
 515   DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( TEST_PROPERTY ), visual, TEST_LOCATION );
 516   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION );
 517
 518   application.GetScene().Add( controlWrapper );
 519
 520   // Render and notify
 521   application.SendNotification();
 522   application.Render();
 523
 524   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION );
 525
 526   DALI_TEST_EQUALS( controlWrapper.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ), true, TEST_LOCATION );
 527
 528   controlWrapperImpl->EnableVisual( TEST_PROPERTY, true );
 529
 530   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), true, TEST_LOCATION );
 531
 532   END_TEST;
 533 }
 534
 535 int UtcDaliControlWrapperRegisterDisabledVisualWithDepthIndex(void)
 536 {
 537   ToolkitTestApplication application;
 538
 539   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 540   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 541
 542   Property::Index TEST_PROPERTY = 1;
 543
 544   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 545   Toolkit::Visual::Base visual;
 546
 547   Property::Map map;
 548   map[Visual::Property::TYPE] = Visual::COLOR;
 549   map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 550
 551   visual = visualFactory.CreateVisual( map );
 552   DALI_TEST_CHECK(visual);
 553
 554   // Register index with a color visual
 555   controlWrapperImpl->RegisterVisual( TEST_PROPERTY, visual, false, 10 );
 556
 557   DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( TEST_PROPERTY ), visual, TEST_LOCATION );
 558   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION );
 559   DALI_TEST_EQUALS( visual.GetDepthIndex(), 10, TEST_LOCATION );
 560
 561   application.GetScene().Add( controlWrapper );
 562
 563   // Render and notify
 564   application.SendNotification();
 565   application.Render();
 566
 567   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), false, TEST_LOCATION );
 568
 569   DALI_TEST_EQUALS( controlWrapper.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ), true, TEST_LOCATION );
 570
 571   controlWrapperImpl->EnableVisual( TEST_PROPERTY, true );
 572
 573   DALI_TEST_EQUALS( controlWrapperImpl->IsVisualEnabled( TEST_PROPERTY ), true, TEST_LOCATION );
 574
 575   END_TEST;
 576 }
 577
 578 int UtcDaliControlWrapperRegisterUnregisterVisual(void)
 579 {
 580   ToolkitTestApplication application;
 581
 582   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 583   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 584
 585   Property::Index index = 1;
 586
 587   Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 588   Toolkit::Visual::Base visual;
 589
 590   Property::Map map;
 591   map[Visual::Property::TYPE] = Visual::COLOR;
 592   map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 593
 594   visual = visualFactory.CreateVisual( map );
 595   DALI_TEST_CHECK(visual);
 596
 597   // Register index with a color visual
 598   controlWrapperImpl->RegisterVisual( index, visual );
 599
 600   DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION );
 601
 602   // Unregister visual
 603   controlWrapperImpl->UnregisterVisual( index );
 604
 605   DALI_TEST_CHECK( !controlWrapperImpl->GetVisual( index ) );
 606
 607   END_TEST;
 608 }
 609
 610 int UtcDaliControlWrapperTransitionDataMap1N(void)
 611 {
 612   TestApplication application;
 613
 614   Property::Map map;
 615   map["target"] = "Actor1";
 616   map["property"] = "randomProperty";
 617   map["initialValue"] = Color::MAGENTA;
 618   map["targetValue"] = Color::RED;
 619   map["animator"] = Property::Map()
 620     .Add("alphaFunction", "EASE_OUT")
 621     .Add("timePeriod", Property::Map()
 622          .Add("delay", 0.5f)
 623          .Add("duration", 1.0f));
 624
 625   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
 626
 627   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 628   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 629
 630   //DummyControl actor = DummyControl::New();
 631   controlWrapper.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 632   controlWrapper.SetProperty( Dali::Actor::Property::NAME,"Actor1");
 633   controlWrapper.SetProperty( Actor::Property::COLOR,Color::CYAN);
 634   application.GetScene().Add(controlWrapper);
 635
 636   Animation anim = controlWrapperImpl->CreateTransition( transition );
 637   DALI_TEST_CHECK( ! anim );
 638
 639   Property::Map returnedMap = transition.GetAnimatorAt(0);
 640
 641   Property::Value* value = returnedMap.Find("property");
 642   DALI_TEST_CHECK( value != NULL);
 643   DALI_TEST_EQUALS( "randomProperty", value->Get<std::string>(), TEST_LOCATION );
 644
 645   value = returnedMap.Find("initialValue");
 646   DALI_TEST_CHECK( value != NULL);
 647   DALI_TEST_EQUALS( Color::MAGENTA, value->Get<Vector4>(), TEST_LOCATION );
 648
 649   value = returnedMap.Find("targetValue");
 650   DALI_TEST_CHECK( value != NULL);
 651   DALI_TEST_EQUALS( Color::RED, value->Get<Vector4>(), TEST_LOCATION );
 652
 653   value = returnedMap.Find("animator");
 654   DALI_TEST_CHECK( value != NULL);
 655   Property::Map returnedAnimatorMap = value->Get<Property::Map>();
 656
 657   value = returnedAnimatorMap.Find("alphaFunction");
 658   DALI_TEST_CHECK( value != NULL);
 659   DALI_TEST_EQUALS( "EASE_OUT", value->Get<std::string>(), TEST_LOCATION );
 660
 661   value = returnedAnimatorMap.Find("timePeriod");
 662   DALI_TEST_CHECK( value != NULL);
 663   Property::Map returnedTimePeriodMap = value->Get<Property::Map>();
 664
 665   value = returnedTimePeriodMap.Find("delay");
 666   DALI_TEST_CHECK( value != NULL);
 667   DALI_TEST_EQUALS( 0.5f, value->Get<float>(), TEST_LOCATION );
 668
 669   value = returnedTimePeriodMap.Find("duration");
 670   DALI_TEST_CHECK( value != NULL);
 671   DALI_TEST_EQUALS( 1.0f, value->Get<float>(), TEST_LOCATION );
 672
 673   END_TEST;
 674 }
 675
 676 int UtcDaliControlWrapperApplyThemeStyle(void)
 677 {
 678   ToolkitTestApplication application;
 679
 680   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 681   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 682
 683   controlWrapperImpl->ApplyThemeStyle();
 684
 685   DALI_TEST_CHECK( true );
 686   END_TEST;
 687 }
 688
 689 int UtcDaliControlWrapperTestControlProperties(void)
 690 {
 691   ToolkitTestApplication application;
 692
 693   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 694   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 695
 696   application.GetScene().Add( controlWrapper );
 697
 698   // "background" property
 699   Property::Map rendererMap;
 700   rendererMap[Visual::Property::TYPE] = Visual::COLOR;
 701   rendererMap[ColorVisual::Property::MIX_COLOR] = Color::RED;
 702   controlWrapper.SetProperty( Control::Property::BACKGROUND, rendererMap );
 703   Property::Value propertyValue = controlWrapper.GetProperty( Control::Property::BACKGROUND );
 704   Property::Map* resultMap = propertyValue.GetMap();
 705   DALI_TEST_CHECK( resultMap->Find( Toolkit::Visual::Property::TYPE ) );
 706   DALI_TEST_EQUALS( resultMap->Find( Toolkit::Visual::Property::TYPE )->Get<int>(), (int)Visual::COLOR, TEST_LOCATION );
 707   DALI_TEST_CHECK( resultMap->Find( ColorVisual::Property::MIX_COLOR ) );
 708   DALI_TEST_EQUALS( resultMap->Find( ColorVisual::Property::MIX_COLOR )->Get<Vector4>(), Color::RED, TEST_LOCATION );
 709
 710   // "keyInputFocus" property
 711   controlWrapper.SetProperty( Control::Property::KEY_INPUT_FOCUS, true );
 712   DALI_TEST_EQUALS( true, controlWrapper.GetProperty( Control::Property::KEY_INPUT_FOCUS ).Get< bool >(), TEST_LOCATION );
 713
 714   // "styleName" property
 715   controlWrapper.SetProperty( Control::Property::STYLE_NAME, "MyCustomStyle" );
 716   DALI_TEST_EQUALS( "MyCustomStyle", controlWrapper.GetProperty( Control::Property::STYLE_NAME ).Get< std::string >(), TEST_LOCATION );
 717
 718   END_TEST;
 719 }
 720
 721 int UtcDaliControlWrapperTypeRegistryCreation(void)
 722 {
 723   ToolkitTestApplication application;
 724
 725   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "ControlWrapper" );
 726   DALI_TEST_CHECK( typeInfo )
 727
 728   // Check that we can't create a ControlWrapper instance
 729   BaseHandle baseHandle = typeInfo.CreateInstance();
 730   DALI_TEST_CHECK( !baseHandle )
 731
 732   END_TEST;
 733 }
 734
 735 void SetProperty(BaseObject* object, const char* const name, Property::Value* value)
 736 {
 737 }
 738 Property::Value* GetProperty(BaseObject* object, const char* const name )
 739 {
 740   return NULL;
 741 }
 742
 743 int UtcDaliControlWrapperAnimateVisual(void)
 744 {
 745   tet_infoline("Test that the control wrapper's visuals can be animated by name when registered");
 746
 747   ToolkitTestApplication application;
 748   Test::ObjectDestructionTracker objectDestructionTracker( application.GetCore().GetObjectRegistry() );
 749
 750   {
 751     Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 752     ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 753
 754     Property::Index index = Control::CONTROL_PROPERTY_END_INDEX+1;
 755     std::string visualName("colorVisual");
 756     CSharpTypeRegistry::RegisterProperty( customControlTypeName, visualName, index, Property::VECTOR4, SetProperty, GetProperty );
 757
 758     objectDestructionTracker.Start( controlWrapper );
 759
 760     Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
 761     Toolkit::Visual::Base visual;
 762
 763     Property::Map map;
 764     map[Visual::Property::TYPE] = Visual::COLOR;
 765     map[ColorVisual::Property::MIX_COLOR] = Color::RED;
 766
 767     visual = visualFactory.CreateVisual( map );
 768     DALI_TEST_CHECK( visual );
 769
 770     // Register to self
 771     controlWrapperImpl->TestRegisterVisual( index, visual );
 772
 773     application.GetScene().Add( controlWrapper );
 774     controlWrapper.SetProperty( Actor::Property::SIZE, Vector2( 100, 100 ) );
 775     application.SendNotification();
 776     application.Render(0); // Trigger animation start
 777
 778     Property::Map transition;
 779     transition["target"] = visualName;
 780     transition["property"] = "mixColor";
 781     transition["targetValue"] = Color::GREEN;
 782     Property::Map animator;
 783     animator["alphaFunction"] = "LINEAR";
 784     animator["duration"] = 1.0f;
 785     animator["delay"] = 0.0f;
 786     transition["animator"] = animator;
 787
 788     TransitionData transitionData = TransitionData::New(transition);
 789     Animation anim = DevelControl::CreateTransition( *controlWrapperImpl, transitionData );
 790     anim.Play();
 791
 792     application.SendNotification();
 793     application.Render(0); // Trigger animation start
 794
 795     application.Render(1000); // animation end
 796     application.Render(  10);
 797
 798     Property::Map visualMap;
 799     visual.CreatePropertyMap( visualMap );
 800     Property::Value* value = visualMap.Find(ColorVisual::Property::MIX_COLOR, "mixColor");
 801     DALI_TEST_CHECK( value != NULL );
 802     if( value )
 803     {
 804       Vector4 testColor = value->Get<Vector4>();
 805       DALI_TEST_EQUALS( testColor, Color::GREEN, 0.001f, TEST_LOCATION );
 806     }
 807
 808     DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), false, TEST_LOCATION ); // Control not destroyed yet
 809     DALI_TEST_EQUALS( controlWrapperImpl->GetVisual( index ), visual, TEST_LOCATION );
 810
 811     application.GetScene().Remove( controlWrapper );
 812   }
 813
 814   DALI_TEST_EQUALS( objectDestructionTracker.IsDestroyed(), true, TEST_LOCATION ); // Should be destroyed
 815
 816   END_TEST;
 817 }
 818
 819 int UtcDaliControlWrapperEmitKeyFocusSignal(void)
 820 {
 821   ToolkitTestApplication application;
 822
 823   Impl::TestCustomControl* controlWrapperImpl = new ::Impl::TestCustomControl( Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_DEFAULT );
 824   ControlWrapper controlWrapper = ControlWrapper::New( customControlTypeName, *controlWrapperImpl );
 825
 826   gKeyInputFocusCallBackCalled = false;
 827   controlWrapper.KeyInputFocusGainedSignal().Connect(&TestKeyInputFocusCallback);
 828
 829   application.SendNotification();
 830   application.Render();
 831
 832   controlWrapperImpl->EmitKeyInputFocusSignal( true );
 833
 834   DALI_TEST_CHECK( gKeyInputFocusCallBackCalled );
 835
 836   END_TEST;
 837 }