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