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

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