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