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

   1 /*
   2  * Copyright (c) 2017 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 #include <iostream>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali/devel-api/object/handle-devel.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  25 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  27 #include <dali-toolkit/dali-toolkit.h>
  28 #include "dummy-control.h"
  29
  30 using namespace Dali;
  31 using namespace Dali::Toolkit;
  32
  33 namespace
  34 {
  35 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  36 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  37 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  38 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  39 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  40 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  41 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
  42
  43 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
  44
  45 Property::Map DefaultTransform()
  46 {
  47   Property::Map transformMap;
  48   transformMap
  49     .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  50     .Add( Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  51     .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
  52     .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN )
  53     .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) )
  54     .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
  55   return transformMap;
  56 }
  57
  58 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
  59 {
  60   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
  61   {
  62     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
  63     {
  64       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
  65
  66       Property::Value* valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
  67       if( NULL != valueSet )
  68       {
  69         if( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() )
  70         {
  71           tet_printf( "  Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
  72           return false;
  73         }
  74       }
  75       else
  76       {
  77         tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
  78         return false;
  79       }
  80     }
  81   }
  82
  83   return true;
  84 }
  85
  86 void PrepareResourceImage( ToolkitTestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  87 {
  88   TestPlatformAbstraction& platform = application.GetPlatform();
  89   platform.SetClosestImageSize(Vector2( imageWidth, imageHeight));
  90
  91   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  92   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  93   unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
  94   unsigned int initialColor = 0xFF;
  95   memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
  96
  97   Integration::ResourcePointer resourcePtr(bitmap);
  98   platform.SetSynchronouslyLoadedResource( resourcePtr );
  99 }
 100 } //namespace
 101
 102 void dali_visual_startup(void)
 103 {
 104   test_return_value = TET_UNDEF;
 105 }
 106
 107 void dali_visual_cleanup(void)
 108 {
 109   test_return_value = TET_PASS;
 110 }
 111
 112
 113 static void TestMixColor( Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor )
 114 {
 115   Property::Map map;
 116   visual.CreatePropertyMap(map);
 117   Property::Value* value = map.Find( mixColorIndex );
 118   DALI_TEST_CHECK( value );
 119   Vector3 mixColor1;
 120   DALI_TEST_CHECK( value->Get( mixColor1 ) );
 121   DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
 122
 123   value = map.Find( Visual::Property::MIX_COLOR );
 124   DALI_TEST_CHECK( value );
 125   Vector4 mixColor2;
 126   DALI_TEST_CHECK( value->Get( mixColor2 ) );
 127   DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
 128
 129   value = map.Find( Visual::Property::OPACITY );
 130   DALI_TEST_CHECK( value );
 131   float opacity;
 132   DALI_TEST_CHECK( value->Get( opacity ) );
 133   DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
 134 }
 135
 136
 137 int UtcDaliVisualCopyAndAssignment(void)
 138 {
 139   ToolkitTestApplication application;
 140   tet_infoline( "UtcDaliVisualCopyAndAssignment" );
 141
 142   VisualFactory factory = VisualFactory::Get();
 143   Property::Map propertyMap;
 144   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 145   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 146   Visual::Base visual = factory.CreateVisual( propertyMap );
 147
 148   Visual::Base visualCopy( visual );
 149   DALI_TEST_CHECK(visual == visualCopy);
 150
 151   Visual::Base emptyVisual;
 152   Visual::Base emptyVisualCopy( emptyVisual );
 153   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 154
 155   Visual::Base visualEquals;
 156   visualEquals = visual;
 157   DALI_TEST_CHECK(visual == visualEquals);
 158
 159   Visual::Base emptyVisualEquals;
 160   emptyVisualEquals = emptyVisual;
 161   DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
 162
 163   //self assignment
 164   visual = visual;
 165   DALI_TEST_CHECK( visual = visualCopy );
 166
 167   END_TEST;
 168 }
 169
 170 int UtcDaliVisualSetName01(void)
 171 {
 172   ToolkitTestApplication application;
 173   tet_infoline( "UtcDaliVisualSetName" );
 174
 175   VisualFactory factory = VisualFactory::Get();
 176   Property::Map propertyMap;
 177   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 178   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 179   Visual::Base visual = factory.CreateVisual( propertyMap );
 180
 181   const char* visualName = "backgroundVisual";
 182   visual.SetName( visualName );
 183
 184   DALI_TEST_EQUALS( visual.GetName(), visualName, TEST_LOCATION );
 185
 186   END_TEST;
 187 }
 188
 189 int UtcDaliVisualSetGetDepthIndex(void)
 190 {
 191   ToolkitTestApplication application;
 192   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 193
 194   VisualFactory factory = VisualFactory::Get();
 195   Property::Map propertyMap;
 196   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 197   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 198   Visual::Base visual = factory.CreateVisual( propertyMap );
 199
 200   visual.SetDepthIndex( 1 );
 201
 202   DummyControl dummyControl = DummyControl::New(true);
 203   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 204   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 205
 206   dummyControl.SetSize(200.f, 200.f);
 207   Stage::GetCurrent().Add( dummyControl );
 208
 209
 210   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 211   DALI_TEST_EQUALS( depthIndex, 1, TEST_LOCATION );
 212   DALI_TEST_EQUALS( visual.GetDepthIndex(), 1, TEST_LOCATION );
 213
 214   visual.SetDepthIndex( -1 );
 215   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 216   DALI_TEST_EQUALS( depthIndex, -1, TEST_LOCATION );
 217   DALI_TEST_EQUALS( visual.GetDepthIndex(), -1, TEST_LOCATION );
 218
 219   END_TEST;
 220 }
 221
 222 int UtcDaliVisualSize(void)
 223 {
 224   ToolkitTestApplication application;
 225   tet_infoline( "UtcDaliVisualGetNaturalSize" );
 226
 227   VisualFactory factory = VisualFactory::Get();
 228   Vector2 controlSize( 20.f, 30.f );
 229   Vector2 naturalSize;
 230
 231   // color colorVisual
 232   Dali::Property::Map map;
 233   map[ Toolkit::Visual::Property::TYPE ] = Visual::COLOR;
 234   map[ ColorVisual::Property::MIX_COLOR ] = Color::MAGENTA;
 235
 236   Visual::Base colorVisual = factory.CreateVisual( map );
 237   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 238
 239   colorVisual.GetNaturalSize(naturalSize);
 240   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 241
 242   // image visual
 243   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 244   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 245   Visual::Base imageVisual = factory.CreateVisual( image );
 246   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 247
 248   imageVisual.GetNaturalSize(naturalSize);
 249   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
 250
 251   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 252
 253   // border visual
 254   float borderSize = 5.f;
 255   map.Clear();
 256   map[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 257   map[ BorderVisual::Property::COLOR  ] = Color::RED;
 258   map[ BorderVisual::Property::SIZE   ] = borderSize;
 259   Visual::Base borderVisual = factory.CreateVisual( map );
 260   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 261   borderVisual.GetNaturalSize(naturalSize);
 262   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 263
 264   // gradient gradientVisual
 265   Property::Map propertyMap;
 266   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 267   Vector2 start(-1.f, -1.f);
 268   Vector2 end(1.f, 1.f);
 269   propertyMap.Insert( "mixColor", Color::MAGENTA );
 270   propertyMap.Insert( GradientVisual::Property::START_POSITION,   start) ;
 271   propertyMap.Insert( GradientVisual::Property::END_POSITION,   end );
 272   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET,   Vector2(0.f, 1.f) );
 273   propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
 274   Property::Array stopColors;
 275   stopColors.PushBack( Color::RED );
 276   stopColors.PushBack( Color::GREEN );
 277   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 278   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 279   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 280   gradientVisual.GetNaturalSize(naturalSize);
 281   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
 282
 283   // svg visual
 284   Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 285   svgVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 286   svgVisual.GetNaturalSize(naturalSize);
 287   // TEST_SVG_FILE:
 288   //  <svg width="100" height="100">
 289   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 290   //  </svg>
 291   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION );
 292
 293   // svg visual with a size
 294   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions(200, 200) );
 295   svgVisual2.GetNaturalSize(naturalSize);
 296   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
 297
 298   // Text visual.
 299
 300   // Load some fonts to get the same metrics on different platforms.
 301   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 302   fontClient.SetDpi( 96u, 96u );
 303
 304   char* pathNamePtr = get_current_dir_name();
 305   const std::string pathName( pathNamePtr );
 306   free( pathNamePtr );
 307
 308   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf" );
 309
 310   propertyMap.Clear();
 311   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
 312   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
 313   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
 314   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
 315
 316   Visual::Base textVisual = factory.CreateVisual( propertyMap );
 317   textVisual.GetNaturalSize( naturalSize );
 318   DALI_TEST_EQUALS( naturalSize, Size( 80.f, 20.f ), TEST_LOCATION );
 319
 320   const float height = textVisual.GetHeightForWidth( 40.f );
 321   DALI_TEST_EQUALS( height, 40.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 322
 323   //AnimatedImageVisual
 324   Visual::Base animatedImageVisual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
 325   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 326   animatedImageVisual.GetNaturalSize(naturalSize);
 327   // TEST_GIF_FILE: anim.gif
 328   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 329   DALI_TEST_EQUALS( naturalSize, Vector2(50.f, 50.f), TEST_LOCATION );
 330
 331   END_TEST;
 332 }
 333
 334 int UtcDaliVisualSetOnOffStage(void)
 335 {
 336   ToolkitTestApplication application;
 337   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 338
 339   VisualFactory factory = VisualFactory::Get();
 340   Property::Map propertyMap;
 341   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 342   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 343   Visual::Base visual = factory.CreateVisual( propertyMap );
 344
 345   DummyControl actor = DummyControl::New(true);
 346   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 347   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 348
 349   actor.SetSize(200.f, 200.f);
 350
 351   application.SendNotification();
 352   application.Render(0);
 353   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 354
 355   Stage::GetCurrent().Add( actor );
 356
 357   application.SendNotification();
 358   application.Render(0);
 359   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 360
 361   Stage::GetCurrent().Remove( actor );
 362
 363   application.SendNotification();
 364   application.Render(0);
 365   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 366
 367   END_TEST;
 368 }
 369
 370 int UtcDaliVisualGetPropertyMap1(void)
 371 {
 372   ToolkitTestApplication application;
 373   tet_infoline( "UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor" );
 374
 375   VisualFactory factory = VisualFactory::Get();
 376   Property::Map propertyMap;
 377   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 378   propertyMap.Insert(Visual::Property::MIX_COLOR,  Color::BLUE);
 379   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 380
 381   Property::Map resultMap;
 382   colorVisual.CreatePropertyMap( resultMap );
 383
 384   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 385   DALI_TEST_CHECK( typeValue );
 386   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 387
 388   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 389   DALI_TEST_CHECK( colorValue );
 390   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 391
 392   // change the blend color
 393   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 394   colorVisual = factory.CreateVisual( propertyMap  );
 395   colorVisual.CreatePropertyMap( resultMap );
 396
 397   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 398   DALI_TEST_CHECK( colorValue );
 399   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 400
 401   END_TEST;
 402 }
 403
 404 int UtcDaliVisualGetPropertyMap2(void)
 405 {
 406   ToolkitTestApplication application;
 407   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 408
 409   VisualFactory factory = VisualFactory::Get();
 410   Property::Map propertyMap;
 411   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 412   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
 413   propertyMap.Insert("borderColor",  Color::BLUE);
 414   propertyMap.Insert("borderSize",  5.f);
 415   propertyMap.Insert("antiAliasing",  true);
 416   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 417
 418   Property::Map resultMap;
 419   borderVisual.CreatePropertyMap( resultMap );
 420
 421   // check the property values from the returned map from visual
 422   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 423   DALI_TEST_CHECK( typeValue );
 424   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 425
 426   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 427   DALI_TEST_CHECK( colorValue );
 428   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 429
 430   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 431   DALI_TEST_CHECK( sizeValue );
 432   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 433
 434   Property::Value* AAValue = resultMap.Find( BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN );
 435   DALI_TEST_CHECK( AAValue );
 436   DALI_TEST_CHECK( AAValue->Get<bool>() == true );
 437
 438   Property::Map propertyMap1;
 439   propertyMap1[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 440   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 441   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 442   borderVisual = factory.CreateVisual( propertyMap1 );
 443   borderVisual.CreatePropertyMap( resultMap );
 444
 445   typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 446   DALI_TEST_CHECK( typeValue );
 447   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 448
 449   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 450   DALI_TEST_CHECK( colorValue );
 451   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 452
 453   colorValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 454   DALI_TEST_CHECK( colorValue );
 455   DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
 456
 457
 458   END_TEST;
 459 }
 460
 461 int UtcDaliVisualGetPropertyMap2N(void)
 462 {
 463   ToolkitTestApplication application;
 464   tet_infoline( "UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties" );
 465
 466   VisualFactory factory = VisualFactory::Get();
 467   Property::Map propertyMap;
 468   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 469   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 470
 471   tet_infoline( "Test that the visual is created, with a default renderer" );
 472   DALI_TEST_CHECK( borderVisual );
 473
 474   DummyControl dummyControl = DummyControl::New(true);
 475   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 476   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
 477   Stage::GetCurrent().Add( dummyControl );
 478
 479   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
 480
 481   END_TEST;
 482 }
 483
 484
 485 int UtcDaliVisualGetPropertyMap3(void)
 486 {
 487   ToolkitTestApplication application;
 488   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 489
 490   VisualFactory factory = VisualFactory::Get();
 491   DALI_TEST_CHECK( factory );
 492
 493   Property::Map propertyMap;
 494   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 495
 496   Vector2 start(-1.f, -1.f);
 497   Vector2 end(1.f, 1.f);
 498   propertyMap.Insert( "startPosition", start);
 499   propertyMap.Insert( "endPosition", end);
 500   propertyMap.Insert( "spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 501
 502   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 503
 504   Property::Array stopColors;
 505   stopColors.PushBack( Color::RED );
 506   stopColors.PushBack( Color::GREEN );
 507   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 508
 509   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 510
 511   Property::Map resultMap;
 512   gradientVisual.CreatePropertyMap( resultMap );
 513
 514   // check the property values from the returned map from visual
 515   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 516   DALI_TEST_CHECK( value );
 517   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 518
 519   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 520   DALI_TEST_CHECK( value );
 521   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 522
 523   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 524   DALI_TEST_CHECK( value );
 525   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 526
 527   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 528   DALI_TEST_CHECK( value );
 529   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 530
 531   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 532   DALI_TEST_CHECK( value );
 533   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 534
 535   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 536   DALI_TEST_CHECK( value );
 537   Property::Array* offsetArray = value->GetArray();
 538   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 539   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 540   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 541
 542   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 543   DALI_TEST_CHECK( value );
 544   Property::Array* colorArray = value->GetArray();
 545   DALI_TEST_CHECK( colorArray->Count() == 2 );
 546   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 547   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 548
 549   END_TEST;
 550 }
 551
 552 int UtcDaliVisualGetPropertyMap4(void)
 553 {
 554   ToolkitTestApplication application;
 555   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 556
 557   VisualFactory factory = VisualFactory::Get();
 558   DALI_TEST_CHECK( factory );
 559
 560   Property::Map propertyMap;
 561   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 562
 563   Vector2 center(100.f, 100.f);
 564   float radius = 100.f;
 565   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 566   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 567   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 568   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 569
 570   Property::Array stopColors;
 571   stopColors.PushBack( Color::RED );
 572   stopColors.PushBack( Color::BLACK );
 573   stopColors.PushBack( Color::GREEN );
 574   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 575
 576   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 577   DALI_TEST_CHECK( gradientVisual );
 578
 579   Property::Map resultMap;
 580   gradientVisual.CreatePropertyMap( resultMap );
 581
 582   // check the property values from the returned map from visual
 583   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 584   DALI_TEST_CHECK( value );
 585   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 586
 587   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 588   DALI_TEST_CHECK( value );
 589   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 590
 591   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 592   DALI_TEST_CHECK( value );
 593   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 594
 595   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 596   DALI_TEST_CHECK( value );
 597   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 598
 599   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 600   DALI_TEST_CHECK( value );
 601   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 602
 603   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 604   DALI_TEST_CHECK( value );
 605   Property::Array* offsetArray = value->GetArray();
 606   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 607   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 608   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 609   // any stop value will be clamped to [0.0, 1.0];
 610   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 611
 612   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 613   DALI_TEST_CHECK( value );
 614   Property::Array* colorArray = value->GetArray();
 615   DALI_TEST_CHECK( colorArray->Count() == 3 );
 616   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 617   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 618   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 619
 620   END_TEST;
 621 }
 622
 623 int UtcDaliVisualGetPropertyMap5(void)
 624 {
 625   ToolkitTestApplication application;
 626   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 627
 628   VisualFactory factory = VisualFactory::Get();
 629   Property::Map propertyMap;
 630   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 631   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
 632   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 633   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 634   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 635   propertyMap.Insert( "fittingMode",   FittingMode::FIT_HEIGHT );
 636   propertyMap.Insert( "samplingMode",   SamplingMode::BOX_THEN_NEAREST );
 637   propertyMap.Insert( "pixelArea", Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 638   propertyMap.Insert( "wrapModeU", WrapMode::REPEAT );
 639   propertyMap.Insert( "wrapModeV", WrapMode::MIRRORED_REPEAT );
 640   propertyMap.Insert( "synchronousLoading",   true );
 641
 642   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 643   DALI_TEST_CHECK( imageVisual );
 644
 645   Property::Map resultMap;
 646   imageVisual.CreatePropertyMap( resultMap );
 647
 648   // check the property values from the returned map from visual
 649   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 650   DALI_TEST_CHECK( value );
 651   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 652
 653   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 654   DALI_TEST_CHECK( value );
 655   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 656
 657   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 658   DALI_TEST_CHECK( value );
 659   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 660
 661   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 662   DALI_TEST_CHECK( value );
 663   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 664
 665   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 666   DALI_TEST_CHECK( value );
 667   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX_THEN_NEAREST );
 668
 669   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 670   DALI_TEST_CHECK( value );
 671   DALI_TEST_CHECK( value->Get<int>() == 20 );
 672
 673   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 674   DALI_TEST_CHECK( value );
 675   DALI_TEST_CHECK( value->Get<int>() == 30 );
 676
 677   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 678   DALI_TEST_CHECK( value );
 679   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.25f, 0.25f, 0.5f, 0.5f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 680
 681   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 682   DALI_TEST_CHECK( value );
 683   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::REPEAT);
 684
 685   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 686   DALI_TEST_CHECK( value );
 687   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 688
 689   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 690   DALI_TEST_CHECK( value );
 691   DALI_TEST_CHECK( value->Get<bool>() == true );
 692
 693   // Get an image visual with an image handle, and test the default property values
 694   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 695   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 696   imageVisual = factory.CreateVisual(image);
 697   imageVisual.CreatePropertyMap( resultMap );
 698
 699   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 700   DALI_TEST_CHECK( value );
 701   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 702
 703   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 704   DALI_TEST_CHECK( value );
 705   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 706
 707   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 708   DALI_TEST_CHECK( value );
 709   DALI_TEST_CHECK( value->Get<int>() == FittingMode::SHRINK_TO_FIT );
 710
 711   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 712   DALI_TEST_CHECK( value );
 713   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX );
 714
 715   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 716   DALI_TEST_CHECK( value );
 717   DALI_TEST_CHECK( value->Get<int>() == 100 );
 718
 719   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 720   DALI_TEST_CHECK( value );
 721   DALI_TEST_CHECK( value->Get<int>() == 200 );
 722
 723   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 724   DALI_TEST_CHECK( value );
 725   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.f, 0.f, 1.f, 1.f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 726
 727   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 728   DALI_TEST_CHECK( value );
 729   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 730
 731   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 732   DALI_TEST_CHECK( value );
 733   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 734
 735   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 736   DALI_TEST_CHECK( value );
 737   DALI_TEST_CHECK( value->Get<bool>() == false );
 738
 739   END_TEST;
 740 }
 741
 742 int UtcDaliVisualGetPropertyMap6(void)
 743 {
 744   ToolkitTestApplication application;
 745   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 746
 747   Rect< int > border( 1, 1, 1, 1 );
 748
 749   VisualFactory factory = VisualFactory::Get();
 750   Property::Map propertyMap;
 751   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 752   propertyMap.Insert( "mixColor",  Color::MAGENTA );
 753   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 754   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 755   propertyMap.Insert( ImageVisual::Property::BORDER, border );
 756   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 757
 758   Property::Map resultMap;
 759   nPatchVisual.CreatePropertyMap( resultMap );
 760
 761   // check the property values from the returned map from visual
 762   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 763   DALI_TEST_CHECK( value );
 764   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 765
 766   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 767   DALI_TEST_CHECK( value );
 768   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 769
 770   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 771   DALI_TEST_CHECK( value );
 772   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 773
 774   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 775   DALI_TEST_CHECK( value );
 776   DALI_TEST_CHECK( value->Get<bool>() );
 777
 778   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 779   DALI_TEST_CHECK( value );
 780   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 781
 782   Vector4 border1( 1.0f, 1.0f, 1.0f, 1.0f );
 783
 784   Property::Map propertyMap1;
 785   propertyMap1.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 786   propertyMap1.Insert( "mixColor",  Color::MAGENTA );
 787   propertyMap1.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 788   propertyMap1.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 789   propertyMap1.Insert( ImageVisual::Property::BORDER, border1 );
 790   nPatchVisual = factory.CreateVisual( propertyMap1 );
 791
 792   nPatchVisual.CreatePropertyMap( resultMap );
 793
 794   // check the property values from the returned map from visual
 795   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 796   DALI_TEST_CHECK( value );
 797   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 798
 799   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 800   DALI_TEST_CHECK( value );
 801   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 802
 803   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 804   DALI_TEST_CHECK( value );
 805   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 806
 807   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 808   DALI_TEST_CHECK( value );
 809   DALI_TEST_CHECK( value->Get<bool>() );
 810
 811   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 812   DALI_TEST_CHECK( value );
 813   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 814
 815   END_TEST;
 816 }
 817
 818 int UtcDaliVisualGetPropertyMap7(void)
 819 {
 820   ToolkitTestApplication application;
 821   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 822
 823   // request SvgVisual with a property map
 824   VisualFactory factory = VisualFactory::Get();
 825   Property::Map propertyMap;
 826   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
 827   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::WHITE );
 828   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 829   propertyMap.Insert( ImageVisual::Property::ATLASING, false );
 830   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 831
 832   Property::Map resultMap;
 833   svgVisual.CreatePropertyMap( resultMap );
 834   // check the property values from the returned map from a visual
 835   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 836   DALI_TEST_CHECK( value );
 837   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 838
 839   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 840   DALI_TEST_CHECK( value );
 841   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 842
 843   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 844   DALI_TEST_CHECK( value );
 845   DALI_TEST_CHECK( value->Get<bool>() == false );
 846
 847   // request SvgVisual with a property map 2
 848   propertyMap.Clear();
 849   propertyMap[ "visualType" ] = Visual::SVG;
 850   propertyMap[ "mixColor" ] = Color::WHITE;
 851   propertyMap[ "url" ] = TEST_SVG_FILE_NAME;
 852   propertyMap[ "atlasing" ] = true;
 853   Visual::Base svgVisual1 = factory.CreateVisual( propertyMap );
 854
 855   resultMap.Clear();
 856   svgVisual1.CreatePropertyMap( resultMap );
 857   // check the property values from the returned map from a visual
 858   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 859   DALI_TEST_CHECK( value );
 860   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 861
 862   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 863   DALI_TEST_CHECK( value );
 864   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 865
 866   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 867   DALI_TEST_CHECK( value );
 868   DALI_TEST_CHECK( value->Get<bool>() == true );
 869
 870   // request SvgVisual with an URL
 871   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 872   resultMap.Clear();
 873   svgVisual2.CreatePropertyMap( resultMap );
 874   // check the property values from the returned map from a visual
 875   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 876   DALI_TEST_CHECK( value );
 877   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 878
 879   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 880   DALI_TEST_CHECK( value );
 881   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 882
 883   END_TEST;
 884 }
 885
 886 //Mesh visual
 887 int UtcDaliVisualGetPropertyMap8(void)
 888 {
 889   ToolkitTestApplication application;
 890   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
 891
 892   //Request MeshVisual using a property map.
 893   VisualFactory factory = VisualFactory::Get();
 894   Property::Map propertyMap;
 895   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
 896   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLUE );
 897   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
 898   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
 899   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
 900   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
 901   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 902   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
 903
 904   Property::Map resultMap;
 905   meshVisual.CreatePropertyMap( resultMap );
 906   TestMixColor( meshVisual, Visual::Property::MIX_COLOR, Color::BLUE );
 907
 908   //Check values in the result map are identical to the initial map's values.
 909   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
 910   DALI_TEST_CHECK( value );
 911   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
 912
 913   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
 914   DALI_TEST_CHECK( value );
 915   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
 916
 917   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
 918   DALI_TEST_CHECK( value );
 919   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
 920
 921   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
 922   DALI_TEST_CHECK( value );
 923   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
 924
 925   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
 926   DALI_TEST_CHECK( value );
 927   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
 928
 929   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 930   DALI_TEST_CHECK( value );
 931   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 932
 933  END_TEST;
 934 }
 935
 936 //Primitive shape visual
 937 int UtcDaliVisualGetPropertyMap9(void)
 938 {
 939   ToolkitTestApplication application;
 940   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
 941
 942   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
 943   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
 944
 945   //Request PrimitiveVisual using a property map.
 946   VisualFactory factory = VisualFactory::Get();
 947   Property::Map propertyMap;
 948   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
 949   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
 950   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
 951   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
 952   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
 953   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
 954   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
 955   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
 956   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
 957   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
 958   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
 959   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
 960   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 961   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
 962
 963   Property::Map resultMap;
 964   primitiveVisual.CreatePropertyMap( resultMap );
 965
 966   //Check values in the result map are identical to the initial map's values.
 967   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
 968   DALI_TEST_CHECK( value );
 969   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
 970
 971   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
 972   DALI_TEST_CHECK( value );
 973   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
 974
 975   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
 976   DALI_TEST_CHECK( value );
 977   DALI_TEST_CHECK( value->Get<Vector4>() == color );
 978   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 979
 980   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
 981   DALI_TEST_CHECK( value );
 982   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
 983
 984   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
 985   DALI_TEST_CHECK( value );
 986   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
 987
 988   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
 989   DALI_TEST_CHECK( value );
 990   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 991
 992   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
 993   DALI_TEST_CHECK( value );
 994   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 995
 996   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
 997   DALI_TEST_CHECK( value );
 998   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 999
1000   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
1001   DALI_TEST_CHECK( value );
1002   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1003
1004   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
1005   DALI_TEST_CHECK( value );
1006   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1007
1008   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
1009   DALI_TEST_CHECK( value );
1010   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1011
1012   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
1013   DALI_TEST_CHECK( value );
1014   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1015
1016   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1017   DALI_TEST_CHECK( value );
1018   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1019
1020   END_TEST;
1021 }
1022
1023 //Text shape visual
1024 int UtcDaliVisualGetPropertyMap10(void)
1025 {
1026   ToolkitTestApplication application;
1027   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
1028
1029   //Request PrimitiveVisual using a property map.
1030   VisualFactory factory = VisualFactory::Get();
1031
1032   Property::Map propertyMap;
1033   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1034   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLACK );
1035   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1036   propertyMap.Insert( "enableMarkup", false );
1037   propertyMap.Insert( "text", "Hello world" );
1038   propertyMap.Insert( "fontFamily", "TizenSans" );
1039
1040   Property::Map fontStyleMapSet;
1041   fontStyleMapSet.Insert( "weight", "bold" );
1042   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1043
1044   propertyMap.Insert( "pointSize", 12.f );
1045   propertyMap.Insert( "multiLine", true );
1046   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1047   propertyMap.Insert( "verticalAlignment", "CENTER" );
1048   propertyMap.Insert( "textColor", Color::RED );
1049   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1050
1051   Property::Map resultMap;
1052   textVisual.CreatePropertyMap( resultMap );
1053
1054   //Check values in the result map are identical to the initial map's values.
1055   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1056   DALI_TEST_CHECK( value );
1057   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION );
1058
1059   value = resultMap.Find( Visual::Property::MIX_COLOR, Property::VECTOR4 );
1060   DALI_TEST_CHECK( value );
1061   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1062
1063   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1064   DALI_TEST_CHECK( value );
1065   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1066
1067   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1068   DALI_TEST_CHECK( value );
1069   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1070
1071   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1072   DALI_TEST_CHECK( value );
1073
1074   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1075   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1076   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1077
1078   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1079   DALI_TEST_CHECK( value );
1080   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1081
1082   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1083   DALI_TEST_CHECK( value );
1084   DALI_TEST_CHECK( value->Get<bool>() );
1085
1086   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER );
1087   DALI_TEST_CHECK( value );
1088   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION );
1089
1090   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER );
1091   DALI_TEST_CHECK( value );
1092   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION );
1093
1094   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1095   DALI_TEST_CHECK( value );
1096   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1097
1098   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1099   DALI_TEST_CHECK( value );
1100   DALI_TEST_CHECK( !value->Get<bool>() );
1101
1102   END_TEST;
1103 }
1104
1105 int UtcDaliVisualAnimateBorderVisual01(void)
1106 {
1107   ToolkitTestApplication application;
1108   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1109
1110   VisualFactory factory = VisualFactory::Get();
1111   Property::Map propertyMap;
1112   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1113   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1114   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1115   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1116   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1117
1118   Property::Map map;
1119   map["target"] = "testVisual";
1120   map["property"] = "mixColor";
1121   map["targetValue"] = Vector4(1,1,1,0);
1122   map["animator"] = Property::Map()
1123     .Add("alphaFunction", "LINEAR")
1124     .Add("timePeriod", Property::Map()
1125          .Add("delay", 0.0f)
1126          .Add("duration", 4.0f));
1127
1128   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1129
1130   DummyControl actor = DummyControl::New(true);
1131   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1132   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1133   actor.SetSize(2000, 2000);
1134   actor.SetParentOrigin(ParentOrigin::CENTER);
1135   Stage::GetCurrent().Add(actor);
1136
1137   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1138
1139   Renderer renderer = actor.GetRendererAt(0);
1140   Property::Index borderColorIndex = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::COLOR );
1141   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, Visual::Property::MIX_COLOR );
1142
1143   Animation animation = dummyImpl.CreateTransition( transition );
1144
1145   // Animate the mix color through the transition, and the border color through
1146   // programmatic method.
1147   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1148   animation.Play();
1149
1150   application.SendNotification();
1151   application.Render(0);
1152   application.Render(2000u); // halfway point between blue and white
1153
1154   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1155   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1156   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1157   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1158
1159   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1160   testColor = Vector4( 1,1,1,0.4f );
1161   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1162   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1163   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ) , true, TEST_LOCATION );
1164
1165   application.Render(2000u);
1166
1167   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1168   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1169   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1170
1171   color = renderer.GetCurrentProperty< Vector4 >( mixColorIndex );
1172   testColor = Vector4(1,1,1,0);
1173   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1174   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1175   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ), true, TEST_LOCATION );
1176
1177   END_TEST;
1178 }
1179
1180
1181 int UtcDaliVisualAnimateBorderVisual02(void)
1182 {
1183   ToolkitTestApplication application;
1184   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1185
1186   VisualFactory factory = VisualFactory::Get();
1187   Property::Map propertyMap;
1188   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1189   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1190   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1191   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1192
1193   DummyControl actor = DummyControl::New(true);
1194   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1195   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1196   actor.SetSize(2000, 2000);
1197   actor.SetParentOrigin(ParentOrigin::CENTER);
1198   Stage::GetCurrent().Add(actor);
1199
1200   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1201
1202   Renderer renderer = actor.GetRendererAt(0);
1203   Property::Index index = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::SIZE );
1204
1205   Animation animation = Animation::New(4.0f);
1206   animation.AnimateTo( Property(renderer, index), 9.0f );
1207   animation.Play();
1208
1209   application.SendNotification();
1210   application.Render(0);
1211   application.Render(2000u); // halfway point
1212
1213   float size = renderer.GetCurrentProperty< float >( index );
1214   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1215   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1216
1217   application.Render(2000u); // halfway point between blue and white
1218
1219   size = renderer.GetCurrentProperty< float >( index );
1220   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1221   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1222
1223   END_TEST;
1224 }
1225
1226 int UtcDaliVisualAnimateColorVisual(void)
1227 {
1228   ToolkitTestApplication application;
1229   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1230
1231   VisualFactory factory = VisualFactory::Get();
1232   Property::Map propertyMap;
1233   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1234   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1235   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1236
1237   DummyControl actor = DummyControl::New(true);
1238   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1239   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1240   actor.SetSize(2000, 2000);
1241   actor.SetParentOrigin(ParentOrigin::CENTER);
1242   Stage::GetCurrent().Add(actor);
1243
1244   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1245
1246   Renderer renderer = actor.GetRendererAt(0);
1247   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
1248
1249   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1250   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1251
1252   Animation animation = Animation::New(4.0f);
1253   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1254   animation.Play();
1255
1256   application.SendNotification();
1257   application.Render(0);
1258   application.Render(2000u); // halfway point
1259
1260   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1261   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1262   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1263
1264   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1265
1266   application.Render(2000u); // halfway point between blue and white
1267
1268   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1269   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1270
1271   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1272
1273   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1274   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1275
1276   END_TEST;
1277 }
1278
1279 int UtcDaliVisualAnimatePrimitiveVisual(void)
1280 {
1281   ToolkitTestApplication application;
1282   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1283
1284   {
1285     VisualFactory factory = VisualFactory::Get();
1286     Property::Map propertyMap;
1287     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1288     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1289     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1290     Visual::Base visual = factory.CreateVisual( propertyMap );
1291
1292     DummyControl actor = DummyControl::New(true);
1293     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1294     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1295     actor.SetSize(2000, 2000);
1296     actor.SetParentOrigin(ParentOrigin::CENTER);
1297     actor.SetColor(Color::BLACK);
1298     Stage::GetCurrent().Add(actor);
1299
1300     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1301
1302     Renderer renderer = actor.GetRendererAt(0);
1303     Property::Index index = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
1304
1305     tet_infoline("Test that the renderer has the Primitive mix color");
1306     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1307
1308     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1309     const Vector4 TARGET_MIX_COLOR( Color::RED );
1310
1311     Property::Map map;
1312     map["target"] = "testVisual";
1313     map["property"] = "mixColor";
1314     map["initialValue"] = INITIAL_MIX_COLOR;
1315     map["targetValue"] = TARGET_MIX_COLOR;
1316     map["animator"] = Property::Map()
1317       .Add("alphaFunction", "LINEAR")
1318       .Add("timePeriod", Property::Map()
1319            .Add("delay", 0.0f)
1320            .Add("duration", 4.0f));
1321
1322     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1323
1324     Animation animation = dummyImpl.CreateTransition( transition );
1325     Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1326     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
1327
1328     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1329     animation.Play();
1330
1331     application.SendNotification();
1332     application.Render(0);
1333     application.Render(2000u); // halfway point
1334     application.SendNotification();
1335
1336     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
1337
1338     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1339     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1340     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", halfwayColor.a ), true, TEST_LOCATION );
1341
1342     application.Render(2001u); // go past end
1343     application.SendNotification(); // Trigger signals
1344
1345     DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1346     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
1347     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1348     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a ), true, TEST_LOCATION );
1349
1350     blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1351     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1352
1353     actor.Unparent();
1354   }
1355
1356   END_TEST;
1357 }
1358
1359
1360 int UtcDaliVisualWireframeVisual(void)
1361 {
1362   ToolkitTestApplication application;
1363
1364   VisualFactory factory = VisualFactory::Get();
1365   Property::Map propertyMap;
1366   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
1367
1368   // Create the visual.
1369   Visual::Base visual = factory.CreateVisual( propertyMap );
1370
1371   DALI_TEST_CHECK( visual );
1372
1373   Property::Map resultMap;
1374   visual.CreatePropertyMap( resultMap );
1375
1376   // Check the property values from the returned map from visual
1377   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1378   DALI_TEST_CHECK( value );
1379   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
1380
1381   END_TEST;
1382 }
1383
1384 int UtcDaliVisualGetTransform(void)
1385 {
1386   ToolkitTestApplication application;
1387   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
1388
1389   VisualFactory factory = VisualFactory::Get();
1390   Property::Map propertyMap;
1391   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1392   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1393   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
1394
1395   Dali::Property::Map visualMap;
1396   colorVisual.CreatePropertyMap( visualMap );
1397   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
1398   Dali::Property::Map* map = value->GetMap();
1399   DALI_TEST_CHECK( map );
1400
1401   //Test default values
1402   {
1403     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
1404     DALI_TEST_CHECK( typeValue );
1405     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
1406   }
1407   {
1408     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
1409     DALI_TEST_CHECK( typeValue );
1410     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
1411   }
1412   {
1413     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
1414     DALI_TEST_CHECK( typeValue );
1415     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
1416   }
1417   {
1418     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
1419     DALI_TEST_CHECK( typeValue );
1420     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
1421   }
1422   {
1423     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
1424     DALI_TEST_CHECK( typeValue );
1425     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
1426   }
1427   {
1428     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
1429     DALI_TEST_CHECK( typeValue );
1430     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
1431   }
1432
1433   END_TEST;
1434 }
1435
1436 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
1437 {
1438   Property::Map transform;
1439   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
1440   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
1441   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
1442   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
1443   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
1444
1445   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1446
1447   Dali::Property::Map visualMap;
1448   visual.CreatePropertyMap( visualMap );
1449   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
1450   Dali::Property::Map* map = value->GetMap();
1451   DALI_TEST_CHECK( map );
1452
1453   {
1454     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
1455     DALI_TEST_CHECK( typeValue );
1456     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
1457   }
1458   {
1459     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
1460     DALI_TEST_CHECK( typeValue );
1461     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
1462   }
1463   {
1464     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
1465     DALI_TEST_CHECK( typeValue );
1466     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
1467   }
1468   {
1469     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
1470     DALI_TEST_CHECK( typeValue );
1471     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
1472   }
1473   {
1474     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
1475     DALI_TEST_CHECK( typeValue );
1476     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
1477   }
1478   {
1479     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
1480     DALI_TEST_CHECK( typeValue );
1481     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
1482   }
1483
1484   //Put the visual on the stage
1485   DummyControl actor = DummyControl::New(true);
1486   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1487   actor.SetSize(2000, 2000);
1488   actor.SetParentOrigin(ParentOrigin::CENTER);
1489   Stage::GetCurrent().Add(actor);
1490
1491   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1492   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
1493
1494   application.SendNotification();
1495   application.Render(0);
1496   Renderer renderer( actor.GetRendererAt(0) );
1497
1498   //Check that the properties have been registered on the Renderer
1499   Property::Index index = renderer.GetPropertyIndex( "offset" );
1500   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1501   Vector2 offset = renderer.GetProperty<Vector2>( index );
1502   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
1503
1504   index = renderer.GetPropertyIndex( "size" );
1505   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1506   Vector2 size = renderer.GetProperty<Vector2>( index );
1507   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
1508
1509   index = renderer.GetPropertyIndex( "offsetSizeMode" );
1510   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1511   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
1512   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1513
1514   index = renderer.GetPropertyIndex( "origin" );
1515   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1516   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
1517   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
1518
1519   index = renderer.GetPropertyIndex( "anchorPoint" );
1520   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1521   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
1522   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1523
1524   //Set a new transform
1525   transform.Clear();
1526   transform = DefaultTransform();
1527   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
1528   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
1529   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
1530   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1531   application.SendNotification();
1532   application.Render(0);
1533
1534   //Check that the values have changed in the renderer
1535   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1536   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
1537
1538   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1539   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
1540
1541   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1542   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
1543
1544   //Parent origin and anchor point should have the default values
1545   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1546   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1547
1548   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1549   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
1550 }
1551
1552 int UtcDaliVisualSetTransform0(void)
1553 {
1554   ToolkitTestApplication application;
1555   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
1556
1557   VisualFactory factory = VisualFactory::Get();
1558   Property::Map propertyMap;
1559   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1560   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1561   Visual::Base visual = factory.CreateVisual( propertyMap );
1562   TestTransform( application, visual );
1563   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
1564
1565   END_TEST;
1566 }
1567
1568 int UtcDaliVisualSetTransform1(void)
1569 {
1570   ToolkitTestApplication application;
1571   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
1572
1573   VisualFactory factory = VisualFactory::Get();
1574   Property::Map propertyMap;
1575   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
1576   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
1577   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
1578   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
1579   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
1580   Visual::Base visual = factory.CreateVisual( propertyMap );
1581   TestTransform( application, visual );
1582   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
1583
1584   END_TEST;
1585 }
1586
1587 int UtcDaliVisualSetTransform2(void)
1588 {
1589   ToolkitTestApplication application;
1590   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
1591
1592   VisualFactory factory = VisualFactory::Get();
1593   Property::Map propertyMap;
1594   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
1595   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
1596
1597   Property::Array stopOffsets;
1598   stopOffsets.PushBack( 0.0f );
1599   stopOffsets.PushBack( 0.3f );
1600   stopOffsets.PushBack( 0.6f );
1601   stopOffsets.PushBack( 0.8f );
1602   stopOffsets.PushBack( 1.0f );
1603   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
1604
1605   Property::Array stopColors;
1606   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
1607   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
1608   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
1609   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
1610   stopColors.PushBack( Color::YELLOW );
1611   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
1612   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
1613   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
1614   Visual::Base visual = factory.CreateVisual( propertyMap );
1615   TestTransform( application, visual );
1616   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
1617
1618   END_TEST;
1619 }
1620
1621 int UtcDaliVisualSetTransform3(void)
1622 {
1623   ToolkitTestApplication application;
1624   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
1625
1626   VisualFactory factory = VisualFactory::Get();
1627   Property::Map propertyMap;
1628   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
1629   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
1630   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
1631   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
1632   Visual::Base visual = factory.CreateVisual( propertyMap );
1633   TestTransform( application, visual );
1634   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
1635
1636   END_TEST;
1637 }
1638
1639 int UtcDaliVisualSetTransform4(void)
1640 {
1641   ToolkitTestApplication application;
1642   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
1643
1644   VisualFactory factory = VisualFactory::Get();
1645   Property::Map propertyMap;
1646   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1647   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
1648
1649   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1650   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1651   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
1652   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1653   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
1654   Visual::Base visual = factory.CreateVisual( propertyMap );
1655   TestTransform( application, visual );
1656   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
1657
1658   END_TEST;
1659 }
1660
1661 int UtcDaliVisualSetTransform5(void)
1662 {
1663   ToolkitTestApplication application;
1664   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
1665
1666   VisualFactory factory = VisualFactory::Get();
1667   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
1668   Visual::Base visual = factory.CreateVisual(image);
1669   TestTransform( application, visual );
1670   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
1671
1672   END_TEST;
1673 }
1674
1675 int UtcDaliVisualSetTransform6(void)
1676 {
1677   ToolkitTestApplication application;
1678   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
1679
1680   VisualFactory factory = VisualFactory::Get();
1681   Property::Map propertyMap;
1682   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
1683   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
1684   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1685   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
1686   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
1687   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
1688   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
1689   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
1690   Visual::Base visual = factory.CreateVisual(propertyMap);
1691   TestTransform( application, visual );
1692   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
1693
1694   END_TEST;
1695 }
1696
1697 int UtcDaliVisualSetTransform7(void)
1698 {
1699   ToolkitTestApplication application;
1700   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
1701
1702   VisualFactory factory = VisualFactory::Get();
1703   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
1704   Visual::Base visual = factory.CreateVisual(image);
1705   TestTransform( application, visual );
1706   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
1707
1708   END_TEST;
1709 }
1710
1711 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
1712 {
1713   ToolkitTestApplication application;
1714   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
1715
1716   VisualFactory factory = VisualFactory::Get();
1717   Property::Map propertyMap;
1718   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1719   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1720   Visual::Base visual = factory.CreateVisual( propertyMap );
1721
1722   Property::Map transform;
1723   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
1724                                                  .Add( "RELATIVE" );
1725   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
1726                                                  .Add( "ABSOLUTE" );
1727   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1728
1729   Dali::Property::Map visualMap;
1730   visual.CreatePropertyMap( visualMap );
1731   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
1732   Dali::Property::Map* map = value->GetMap();
1733   DALI_TEST_CHECK( map );
1734
1735   {
1736     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
1737     DALI_TEST_CHECK( typeValue );
1738     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
1739   }
1740   {
1741     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
1742     DALI_TEST_CHECK( typeValue );
1743     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
1744   }
1745
1746   END_TEST;
1747 }
1748
1749 int UtcDaliNPatchVisualCustomShader(void)
1750 {
1751   ToolkitTestApplication application;
1752   tet_infoline( "NPatchVisual with custom shader" );
1753
1754   VisualFactory factory = VisualFactory::Get();
1755   Property::Map properties;
1756   Property::Map shader;
1757   const std::string vertexShader = "Foobar";
1758   const std::string fragmentShader = "Foobar";
1759   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
1760   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
1761
1762   Property::Map transformMap;
1763   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
1764   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
1765   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
1766   transformMap["anchorPoint"] = Align::CENTER;
1767   transformMap["origin"] = Align::CENTER;
1768   properties[Visual::Property::TRANSFORM] = transformMap;
1769
1770   properties[Visual::Property::TYPE] = Visual::IMAGE;
1771   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
1772   properties[Visual::Property::SHADER]=shader;
1773   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
1774
1775   Visual::Base visual = factory.CreateVisual( properties );
1776   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
1777
1778   // trigger creation through setting on stage
1779   DummyControl dummy = DummyControl::New(true);
1780   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
1781   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1782   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
1783   dummy.SetSize(2000, 2000);
1784   dummy.SetParentOrigin(ParentOrigin::CENTER);
1785   Stage::GetCurrent().Add(dummy);
1786   application.SendNotification();
1787
1788   Renderer renderer = dummy.GetRendererAt( 0 );
1789   Shader shader2 = renderer.GetShader();
1790   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
1791   Property::Map* map = value.GetMap();
1792   DALI_TEST_CHECK( map );
1793
1794   Property::Index index = renderer.GetPropertyIndex("size");
1795   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
1796
1797   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
1798   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
1799
1800   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
1801   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
1802
1803   END_TEST;
1804 }
1805
1806 int UtcDaliGradientVisualBlendMode(void)
1807 {
1808   ToolkitTestApplication application;
1809   VisualFactory factory = VisualFactory::Get();
1810
1811   Visual::Base opaqueGradientVisual = factory.CreateVisual(
1812       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
1813                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1814                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1815                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1816                                                                                   .Add( Color::GREEN ) ) );
1817
1818   Visual::Base alphaGradientVisual = factory.CreateVisual(
1819       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
1820                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1821                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1822                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1823                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
1824
1825   DummyControl control = DummyControl::New(true);
1826   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1827   Stage::GetCurrent().Add( control );
1828
1829   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
1830   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
1831   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
1832
1833   application.SendNotification();
1834   application.Render();
1835
1836   // Control should have two renderers, the first one is opaque so our blending mode should be off, the second one has some alpha so should be set to automatic
1837   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
1838   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
1839   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1840
1841   END_TEST;
1842 }
1843
1844 int UtcDaliVisualRendererRemovalAndReAddition(void)
1845 {
1846   ToolkitTestApplication application;
1847   tet_infoline( "UtcDaliVisualRendererRemoval" );
1848
1849   VisualFactory factory = VisualFactory::Get();
1850   Property::Map propertyMap;
1851   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1852   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1853   Visual::Base visual = factory.CreateVisual( propertyMap );
1854
1855   visual.SetDepthIndex( 1 );
1856
1857   DummyControl dummyControl = DummyControl::New(true);
1858   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1859   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1860   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1861
1862   dummyControl.SetSize(200.f, 200.f);
1863   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
1864
1865   Stage::GetCurrent().Add( dummyControl );
1866
1867   application.SendNotification();
1868   application.Render();
1869
1870   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1871
1872   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
1873   Stage::GetCurrent().Remove( dummyControl );
1874   application.SendNotification();
1875   application.Render();
1876
1877   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1878
1879   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
1880
1881   Stage::GetCurrent().Add( dummyControl );
1882
1883   application.SendNotification();
1884   application.Render();
1885
1886   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1887
1888   END_TEST;
1889 }
1890
1891
1892
1893 int UtcDaliVisualTextVisualRender(void)
1894 {
1895   ToolkitTestApplication application;
1896   tet_infoline( "UtcDaliVisualTextVisualRender" );
1897
1898   VisualFactory factory = VisualFactory::Get();
1899   Property::Map propertyMap;
1900   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1901   propertyMap.Insert( "mixColor", Color::WHITE );
1902   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1903   propertyMap.Insert( "enableMarkup", false );
1904   propertyMap.Insert( "text", "Hello world" );
1905   propertyMap.Insert( "fontFamily", "TizenSans" );
1906
1907   Property::Map fontStyleMapSet;
1908   fontStyleMapSet.Insert( "weight", "bold" );
1909   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1910
1911   propertyMap.Insert( "pointSize", 12.f );
1912   propertyMap.Insert( "multiLine", true );
1913   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1914   propertyMap.Insert( "verticalAlignment", "CENTER" );
1915   propertyMap.Insert( "textColor", Color::RED );
1916   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1917   textVisual.SetDepthIndex( 1 );
1918
1919   DummyControl dummyControl = DummyControl::New(true);
1920   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1921   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1922   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1923
1924   dummyControl.SetSize(200.f, 200.f);
1925   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
1926
1927   Stage::GetCurrent().Add( dummyControl );
1928   application.SendNotification();
1929   application.Render();
1930
1931
1932   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
1933   propertyMap.Clear();
1934   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1935   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
1936   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
1937   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
1938
1939   Property::Map transformMap;
1940   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
1941   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
1942
1943   textVisual = factory.CreateVisual( propertyMap );
1944   textVisual.SetDepthIndex( 1 );
1945
1946   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1947   dummyControl.SetSize( 720.f, 640.f );
1948
1949   application.SendNotification(); // force process events to ensure text visual
1950   // adds renderer to the dummy control in OnRelayout
1951   application.Render();
1952
1953   Renderer renderer = dummyControl.GetRendererAt(0u);
1954   Property::Index index = renderer.GetPropertyIndex("size");
1955
1956   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
1957   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
1958
1959   END_TEST;
1960 }
1961
1962 int UtcDaliVisualTextVisualDisableEnable(void)
1963 {
1964   ToolkitTestApplication application;
1965   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
1966
1967   VisualFactory factory = VisualFactory::Get();
1968   Property::Map propertyMap;
1969   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1970   propertyMap.Insert( "mixColor", Color::WHITE );
1971   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1972   propertyMap.Insert( "enableMarkup", false );
1973   propertyMap.Insert( "text", "Hello world" );
1974   propertyMap.Insert( "fontFamily", "TizenSans" );
1975
1976   Property::Map fontStyleMapSet;
1977   fontStyleMapSet.Insert( "weight", "bold" );
1978   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1979
1980   propertyMap.Insert( "pointSize", 12.f );
1981   propertyMap.Insert( "multiLine", true );
1982   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1983   propertyMap.Insert( "verticalAlignment", "CENTER" );
1984   propertyMap.Insert( "textColor", Color::RED );
1985   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1986   textVisual.SetDepthIndex( 1 );
1987
1988   DummyControl dummyControl = DummyControl::New(true);
1989   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1990   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1991   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1992
1993   dummyControl.SetSize(200.f, 200.f);
1994   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
1995
1996   Stage::GetCurrent().Add( dummyControl );
1997   application.SendNotification();
1998   application.Render();
1999
2000   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2001
2002   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
2003
2004   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2005
2006   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
2007
2008   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2009
2010   END_TEST;
2011 }
2012
2013 int UtcDaliVisualPremultipliedAlpha(void)
2014 {
2015   ToolkitTestApplication application;
2016   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
2017
2018   VisualFactory factory = VisualFactory::Get();
2019
2020   // image visual, test default value ( false )
2021   {
2022     Visual::Base imageVisual = factory.CreateVisual(
2023           Property::Map()
2024           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
2025           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
2026
2027     Dali::Property::Map visualMap;
2028     imageVisual.CreatePropertyMap( visualMap );
2029     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
2030
2031     // test values
2032     DALI_TEST_CHECK( value );
2033     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
2034   }
2035
2036   // image visual, override premultiplied
2037   {
2038     Visual::Base imageVisual = factory.CreateVisual(
2039           Property::Map()
2040           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
2041           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
2042           .Add( Visual::Property::PREMULTIPLIED_ALPHA, true ) );
2043
2044     Dali::Property::Map visualMap;
2045     imageVisual.CreatePropertyMap( visualMap );
2046     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
2047
2048     // test values
2049     DALI_TEST_CHECK( value );
2050     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
2051   }
2052
2053   // svg visual ( premultiplied alpha by default is true )
2054   {
2055     Visual::Base imageVisual = factory.CreateVisual(
2056           Property::Map()
2057           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
2058           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
2059
2060     Dali::Property::Map visualMap;
2061     imageVisual.CreatePropertyMap( visualMap );
2062     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
2063
2064     // test values
2065     DALI_TEST_CHECK( value );
2066     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
2067   }
2068
2069   END_TEST;
2070 }
2071
2072 int UtcDaliRegisterVisualOrder(void)
2073 {
2074   ToolkitTestApplication application;
2075   tet_infoline( "Register Visual Order" );
2076
2077   DummyControl dummyControl = DummyControl::New(true);
2078   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2079
2080   VisualFactory factory = VisualFactory::Get();
2081   Property::Map propertyMap;
2082   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2083   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2084
2085   tet_infoline( "Register visual, should have depth index of 0.0f" );
2086   Visual::Base testVisual = factory.CreateVisual( propertyMap );
2087   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
2088   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
2089
2090   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
2091
2092   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
2093   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
2094   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
2095
2096   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
2097   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
2098   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
2099
2100   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
2101   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
2102   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
2103
2104   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
2105   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
2106   labelVisual.SetDepthIndex( -2000 );
2107   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
2108   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
2109
2110   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
2111   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
2112   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
2113   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
2114   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
2115   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
2116
2117   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
2118   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
2119   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
2120   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
2121   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
2122
2123   dummyControl.SetSize(200.f, 200.f);
2124   Stage::GetCurrent().Add( dummyControl );
2125
2126   END_TEST;
2127 }
2128
2129 int UtcDaliRegisterVisualOrder02(void)
2130 {
2131   ToolkitTestApplication application;
2132   tet_infoline( "Register Visual Order with Background Set" );
2133
2134   DummyControl dummyControl = DummyControl::New(true);
2135   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2136
2137   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
2138
2139   VisualFactory factory = VisualFactory::Get();
2140   Property::Map propertyMap;
2141   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2142   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2143
2144   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
2145
2146   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
2147
2148   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
2149   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
2150   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
2151   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
2152   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
2153
2154   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
2155   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
2156   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
2157   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
2158
2159   dummyControl.SetSize(200.f, 200.f);
2160   Stage::GetCurrent().Add( dummyControl );
2161
2162   END_TEST;
2163 }
2164
2165 int UtcDaliRegisterVisualWithDepthIndex(void)
2166 {
2167   ToolkitTestApplication application;
2168   tet_infoline( "Register a Visual With Depth Index" );
2169
2170   DummyControl dummyControl = DummyControl::New(true);
2171   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2172
2173   VisualFactory factory = VisualFactory::Get();
2174   Property::Map propertyMap;
2175   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2176   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2177
2178   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
2179   Visual::Base testVisual = factory.CreateVisual( propertyMap );
2180   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
2181   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
2182   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
2183
2184   tet_infoline( "Register another visual with a depth index and it disabled" );
2185   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
2186   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
2187   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
2188   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
2189
2190   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
2191   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
2192   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
2193   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
2194   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
2195
2196   dummyControl.SetSize(200.f, 200.f);
2197   Stage::GetCurrent().Add( dummyControl );
2198
2199   END_TEST;
2200 }