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