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

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