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

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