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

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