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