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
1463 int UtcDaliVisualWireframeVisual(void)
1464 {
1465   ToolkitTestApplication application;
1466
1467   VisualFactory factory = VisualFactory::Get();
1468   Property::Map propertyMap;
1469   propertyMap.Insert( Visual::Property::TYPE, Visual::WIREFRAME );
1470
1471   // Create the visual.
1472   Visual::Base visual = factory.CreateVisual( propertyMap );
1473
1474   DALI_TEST_CHECK( visual );
1475
1476   Property::Map resultMap;
1477   visual.CreatePropertyMap( resultMap );
1478
1479   // Check the property values from the returned map from visual
1480   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
1481   DALI_TEST_CHECK( value );
1482   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
1483
1484   END_TEST;
1485 }
1486
1487 int UtcDaliVisualGetTransform(void)
1488 {
1489   ToolkitTestApplication application;
1490   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
1491
1492   VisualFactory factory = VisualFactory::Get();
1493   Property::Map propertyMap;
1494   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1495   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1496   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
1497
1498   Dali::Property::Map visualMap;
1499   colorVisual.CreatePropertyMap( visualMap );
1500   Property::Value* value = visualMap.Find( Dali::Toolkit::DevelVisual::Property::TRANSFORM );
1501   Dali::Property::Map* map = value->GetMap();
1502   DALI_TEST_CHECK( map );
1503
1504   //Test default values
1505   {
1506     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET );
1507     DALI_TEST_CHECK( typeValue );
1508     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
1509   }
1510   {
1511     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE );
1512     DALI_TEST_CHECK( typeValue );
1513     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
1514   }
1515   {
1516     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE );
1517     DALI_TEST_CHECK( typeValue );
1518     DALI_TEST_CHECK( typeValue->Get<Vector4>() == Vector4(0.0f,0.0f,0.0f,0.0f) );
1519   }
1520   {
1521     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ORIGIN );
1522     DALI_TEST_CHECK( typeValue );
1523     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::CENTER );
1524   }
1525   {
1526     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT );
1527     DALI_TEST_CHECK( typeValue );
1528     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::CENTER );
1529   }
1530
1531   END_TEST;
1532 }
1533
1534 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
1535 {
1536   Property::Map transform;
1537   transform.Insert( DevelVisual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
1538   transform.Insert( DevelVisual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
1539   transform.Insert( DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4(1.0f, 1.0f, 0.0f,0.0f) );
1540   transform.Insert( DevelVisual::Transform::Property::ORIGIN, "TOP_BEGIN" );
1541   transform.Insert( DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
1542
1543   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1544
1545   Dali::Property::Map visualMap;
1546   visual.CreatePropertyMap( visualMap );
1547   Property::Value* value = visualMap.Find( Dali::Toolkit::DevelVisual::Property::TRANSFORM );
1548   Dali::Property::Map* map = value->GetMap();
1549   DALI_TEST_CHECK( map );
1550
1551   {
1552     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET );
1553     DALI_TEST_CHECK( typeValue );
1554     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
1555   }
1556   {
1557     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE );
1558     DALI_TEST_CHECK( typeValue );
1559     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
1560   }
1561   {
1562     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET_SIZE_MODE );
1563     DALI_TEST_CHECK( typeValue );
1564     DALI_TEST_EQUALS( typeValue->Get<Vector4>(), Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1565   }
1566   {
1567     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ORIGIN );
1568     DALI_TEST_CHECK( typeValue );
1569     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::TOP_BEGIN, TEST_LOCATION );
1570   }
1571   {
1572     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT );
1573     DALI_TEST_CHECK( typeValue );
1574     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
1575   }
1576
1577   //Put the visual on the stage
1578   DummyControl actor = DummyControl::New(true);
1579   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1580   actor.SetSize(2000, 2000);
1581   actor.SetParentOrigin(ParentOrigin::CENTER);
1582   Stage::GetCurrent().Add(actor);
1583
1584   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1585   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
1586
1587   application.SendNotification();
1588   application.Render(0);
1589   Renderer renderer( actor.GetRendererAt(0) );
1590
1591   //Check that the properties have been registered on the Renderer
1592   Property::Index index = renderer.GetPropertyIndex( "offset" );
1593   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1594   Vector2 offset = renderer.GetProperty<Vector2>( index );
1595   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
1596
1597   index = renderer.GetPropertyIndex( "size" );
1598   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1599   Vector2 size = renderer.GetProperty<Vector2>( index );
1600   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
1601
1602   index = renderer.GetPropertyIndex( "offsetSizeMode" );
1603   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1604   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
1605   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1606
1607   index = renderer.GetPropertyIndex( "origin" );
1608   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1609   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
1610   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1611
1612   index = renderer.GetPropertyIndex( "anchorPoint" );
1613   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1614   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
1615   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1616
1617   //Set a new transform
1618   transform.Clear();
1619   transform.Insert( DevelVisual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
1620   transform.Insert( DevelVisual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
1621   transform.Insert( DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4(0.0f, 0.0f, 1.0f,1.0f) );
1622   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1623   application.SendNotification();
1624   application.Render(0);
1625
1626   //Check that the values have changed in the renderer
1627   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1628   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
1629
1630   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1631   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
1632
1633   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1634   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
1635
1636   //Parent origin and anchor point should have default values
1637   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1638   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
1639
1640   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1641   DALI_TEST_EQUALS( anchorPoint, Vector2(0.0f,0.0f), TEST_LOCATION );
1642 }
1643
1644 int UtcDaliVisualSetTransform0(void)
1645 {
1646   ToolkitTestApplication application;
1647   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
1648
1649   VisualFactory factory = VisualFactory::Get();
1650   Property::Map propertyMap;
1651   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1652   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1653   Visual::Base visual = factory.CreateVisual( propertyMap );
1654   TestTransform( application, visual );
1655   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
1656
1657   END_TEST;
1658 }
1659
1660 int UtcDaliVisualSetTransform1(void)
1661 {
1662   ToolkitTestApplication application;
1663   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
1664
1665   VisualFactory factory = VisualFactory::Get();
1666   Property::Map propertyMap;
1667   propertyMap[ Visual::Property::TYPE           ] = Visual::PRIMITIVE;
1668   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
1669   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
1670   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
1671   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
1672   Visual::Base visual = factory.CreateVisual( propertyMap );
1673   TestTransform( application, visual );
1674   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
1675
1676   END_TEST;
1677 }
1678
1679 int UtcDaliVisualSetTransform2(void)
1680 {
1681   ToolkitTestApplication application;
1682   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
1683
1684   VisualFactory factory = VisualFactory::Get();
1685   Property::Map propertyMap;
1686   propertyMap.Insert( Visual::Property::TYPE,  Visual::GRADIENT );
1687   propertyMap.Insert( DevelVisual::Property::MIX_COLOR,  Color::GREEN );
1688
1689   Property::Array stopOffsets;
1690   stopOffsets.PushBack( 0.0f );
1691   stopOffsets.PushBack( 0.3f );
1692   stopOffsets.PushBack( 0.6f );
1693   stopOffsets.PushBack( 0.8f );
1694   stopOffsets.PushBack( 1.0f );
1695   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
1696
1697   Property::Array stopColors;
1698   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
1699   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
1700   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
1701   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
1702   stopColors.PushBack( Color::YELLOW );
1703   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
1704   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
1705   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
1706   Visual::Base visual = factory.CreateVisual( propertyMap );
1707   TestTransform( application, visual );
1708   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::GREEN );
1709
1710   END_TEST;
1711 }
1712
1713 int UtcDaliVisualSetTransform3(void)
1714 {
1715   ToolkitTestApplication application;
1716   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
1717
1718   VisualFactory factory = VisualFactory::Get();
1719   Property::Map propertyMap;
1720   propertyMap.Insert( Visual::Property::TYPE, Visual::BORDER );
1721   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1722   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
1723   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
1724   Visual::Base visual = factory.CreateVisual( propertyMap );
1725   TestTransform( application, visual );
1726   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1727
1728   END_TEST;
1729 }
1730
1731 int UtcDaliVisualSetTransform4(void)
1732 {
1733   ToolkitTestApplication application;
1734   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
1735
1736   VisualFactory factory = VisualFactory::Get();
1737   Property::Map propertyMap;
1738   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
1739   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::CYAN );
1740
1741   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1742   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1743   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
1744   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1745   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
1746   Visual::Base visual = factory.CreateVisual( propertyMap );
1747   TestTransform( application, visual );
1748   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::CYAN );
1749
1750   END_TEST;
1751 }
1752
1753 int UtcDaliVisualSetTransform5(void)
1754 {
1755   ToolkitTestApplication application;
1756   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
1757
1758   VisualFactory factory = VisualFactory::Get();
1759   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
1760   Visual::Base visual = factory.CreateVisual(image);
1761   TestTransform( application, visual );
1762   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1763
1764   END_TEST;
1765 }
1766
1767 int UtcDaliVisualSetTransform6(void)
1768 {
1769   ToolkitTestApplication application;
1770   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
1771
1772   VisualFactory factory = VisualFactory::Get();
1773   Property::Map propertyMap;
1774   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
1775   propertyMap[DevelVisual::Property::MIX_COLOR] = Color::YELLOW;
1776   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1777   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
1778   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
1779   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
1780   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
1781   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
1782   Visual::Base visual = factory.CreateVisual(propertyMap);
1783   TestTransform( application, visual );
1784   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::YELLOW );
1785
1786   END_TEST;
1787 }
1788
1789 int UtcDaliVisualSetTransform7(void)
1790 {
1791   ToolkitTestApplication application;
1792   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
1793
1794   VisualFactory factory = VisualFactory::Get();
1795   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
1796   Visual::Base visual = factory.CreateVisual(image);
1797   TestTransform( application, visual );
1798   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1799
1800   END_TEST;
1801 }
1802
1803 int UtcDaliNPatchVisualCustomShader(void)
1804 {
1805   ToolkitTestApplication application;
1806   tet_infoline( "NPatchVisual with custom shader" );
1807
1808   VisualFactory factory = VisualFactory::Get();
1809   Property::Map properties;
1810   Property::Map shader;
1811   const std::string fragmentShader = "Foobar";
1812   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
1813
1814   Property::Map transformMap;
1815   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
1816   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
1817   transformMap["offsetSizeMode"] = Vector4( 1.0f, 1.0f, 0.0f, 0.0f );
1818   transformMap["anchorPoint"] = Align::CENTER;
1819   transformMap["origin"] = Align::CENTER;
1820   properties[DevelVisual::Property::TRANSFORM] = transformMap;
1821
1822   properties[Visual::Property::TYPE] = Visual::IMAGE;
1823   properties[DevelVisual::Property::MIX_COLOR] = Color::BLUE;
1824   properties[Visual::Property::SHADER]=shader;
1825   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
1826
1827   Visual::Base visual = factory.CreateVisual( properties );
1828   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::BLUE );
1829
1830   // trigger creation through setting on stage
1831   DummyControl dummy = DummyControl::New(true);
1832   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
1833   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1834   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
1835   dummy.SetSize(2000, 2000);
1836   dummy.SetParentOrigin(ParentOrigin::CENTER);
1837   Stage::GetCurrent().Add(dummy);
1838   application.SendNotification();
1839
1840   Renderer renderer = dummy.GetRendererAt( 0 );
1841   Shader shader2 = renderer.GetShader();
1842   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
1843   Property::Map* map = value.GetMap();
1844   DALI_TEST_CHECK( map );
1845
1846   Property::Index index = renderer.GetPropertyIndex("size");
1847   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
1848
1849   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
1850   // *map["vertex"]; is default here so not verifying it
1851
1852   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
1853
1854   END_TEST;
1855 }
1856
1857 int UtcDaliGradientVisualBlendMode(void)
1858 {
1859   ToolkitTestApplication application;
1860   VisualFactory factory = VisualFactory::Get();
1861
1862   Visual::Base opaqueGradientVisual = factory.CreateVisual(
1863       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1864                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1865                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1866                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1867                                                                                   .Add( Color::GREEN ) ) );
1868
1869   Visual::Base alphaGradientVisual = factory.CreateVisual(
1870       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1871                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1872                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1873                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1874                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
1875
1876   DummyControl control = DummyControl::New(true);
1877   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1878   Stage::GetCurrent().Add( control );
1879
1880   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
1881   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
1882   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
1883
1884   application.SendNotification();
1885   application.Render();
1886
1887   // 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
1888   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
1889   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
1890   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1891
1892   END_TEST;
1893 }
1894
1895 int UtcDaliVisualRendererRemovalAndReAddition(void)
1896 {
1897   ToolkitTestApplication application;
1898   tet_infoline( "UtcDaliVisualRendererRemoval" );
1899
1900   VisualFactory factory = VisualFactory::Get();
1901   Property::Map propertyMap;
1902   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1903   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1904   Visual::Base visual = factory.CreateVisual( propertyMap );
1905
1906   visual.SetDepthIndex( 1.f );
1907
1908   DummyControl dummyControl = DummyControl::New(true);
1909   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1910   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1911   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1912
1913   dummyControl.SetSize(200.f, 200.f);
1914   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
1915
1916   Stage::GetCurrent().Add( dummyControl );
1917
1918   application.SendNotification();
1919   application.Render();
1920
1921   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1922
1923   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
1924   Stage::GetCurrent().Remove( dummyControl );
1925   application.SendNotification();
1926   application.Render();
1927
1928   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1929
1930   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
1931
1932   Stage::GetCurrent().Add( dummyControl );
1933
1934   application.SendNotification();
1935   application.Render();
1936
1937   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1938
1939   END_TEST;
1940 }
1941
1942
1943
1944 int UtcDaliVisualTextVisualRender(void)
1945 {
1946   ToolkitTestApplication application;
1947   tet_infoline( "UtcDaliVisualTextVisualRender" );
1948
1949   VisualFactory factory = VisualFactory::Get();
1950   Property::Map propertyMap;
1951   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1952   propertyMap.Insert( "mixColor", Color::WHITE );
1953   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1954   propertyMap.Insert( "enableMarkup", false );
1955   propertyMap.Insert( "text", "Hello world" );
1956   propertyMap.Insert( "fontFamily", "TizenSans" );
1957
1958   Property::Map fontStyleMapSet;
1959   fontStyleMapSet.Insert( "weight", "bold" );
1960   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1961
1962   propertyMap.Insert( "pointSize", 12.f );
1963   propertyMap.Insert( "multiLine", true );
1964   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1965   propertyMap.Insert( "verticalAlignment", "CENTER" );
1966   propertyMap.Insert( "textColor", Color::RED );
1967   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1968   textVisual.SetDepthIndex( 1.f );
1969
1970   DummyControl dummyControl = DummyControl::New(true);
1971   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1972   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1973   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1974
1975   dummyControl.SetSize(200.f, 200.f);
1976   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
1977
1978   Stage::GetCurrent().Add( dummyControl );
1979   application.SendNotification();
1980   application.Render();
1981
1982
1983   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
1984   propertyMap.Clear();
1985   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1986   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
1987   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
1988   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
1989
1990   Property::Map transformMap;
1991   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
1992   propertyMap.Insert( DevelVisual::Property::TRANSFORM, transformMap );
1993
1994   textVisual = factory.CreateVisual( propertyMap );
1995   textVisual.SetDepthIndex( 1.f );
1996
1997   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1998   dummyControl.SetSize( 720.f, 640.f );
1999
2000   application.SendNotification(); // force process events to ensure text visual
2001   // adds renderer to the dummy control in OnRelayout
2002   application.Render();
2003
2004   Renderer renderer = dummyControl.GetRendererAt(0u);
2005   Property::Index index = renderer.GetPropertyIndex("size");
2006
2007   tet_infoline( "Test that the TextVisual overrides anything set by developer" );
2008   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 1.0, 1.0 ), 0.001f, TEST_LOCATION );
2009
2010   END_TEST;
2011 }
2012
2013 int UtcDaliVisualPremultipliedAlpha(void)
2014 {
2015   ToolkitTestApplication application;
2016   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
2017
2018   VisualFactory factory = VisualFactory::Get();
2019
2020   // image visual, test default value ( false )
2021   {
2022     Visual::Base imageVisual = factory.CreateVisual(
2023           Property::Map()
2024           .Add( Visual::Property::TYPE, Visual::IMAGE )
2025           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
2026
2027     Dali::Property::Map visualMap;
2028     imageVisual.CreatePropertyMap( visualMap );
2029     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2030
2031     // test values
2032     DALI_TEST_CHECK( value );
2033     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
2034   }
2035
2036   // image visual, override premultiplied
2037   {
2038     Visual::Base imageVisual = factory.CreateVisual(
2039           Property::Map()
2040           .Add( Visual::Property::TYPE, Visual::IMAGE )
2041           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
2042           .Add( DevelVisual::Property::PREMULTIPLIED_ALPHA, true ) );
2043
2044     Dali::Property::Map visualMap;
2045     imageVisual.CreatePropertyMap( visualMap );
2046     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2047
2048     // test values
2049     DALI_TEST_CHECK( value );
2050     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
2051   }
2052
2053   // svg visual ( premultiplied alpha by default is true )
2054   {
2055     Visual::Base imageVisual = factory.CreateVisual(
2056           Property::Map()
2057           .Add( Visual::Property::TYPE, Visual::IMAGE )
2058           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
2059
2060     Dali::Property::Map visualMap;
2061     imageVisual.CreatePropertyMap( visualMap );
2062     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2063
2064     // test values
2065     DALI_TEST_CHECK( value );
2066     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
2067   }
2068
2069   END_TEST;
2070 }