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

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <iostream>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali/public-api/rendering/renderer.h>
  23 #include <dali/public-api/rendering/texture-set.h>
  24 #include <dali/public-api/rendering/shader.h>
  25 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  26 #include <dali-toolkit/devel-api/visual-factory/devel-visual-properties.h>
  27 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
  28 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  29 #include <dali-toolkit/devel-api/align-enums.h>
  30 #include <dali-toolkit/dali-toolkit.h>
  31 #include "dummy-control.h"
  32
  33 using namespace Dali;
  34 using namespace Dali::Toolkit;
  35
  36 namespace
  37 {
  38 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  39 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  40 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  41 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  42 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  43 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
  44
  45 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
  46
  47 Property::Map DefaultTransform()
  48 {
  49   Property::Map transformMap;
  50   transformMap
  51     .Add( Toolkit::VisualProperty::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  52     .Add( Toolkit::VisualProperty::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  53     .Add( Toolkit::VisualProperty::Transform::Property::ORIGIN, Toolkit::Align::CENTER )
  54     .Add( Toolkit::VisualProperty::Transform::Property::ANCHOR_POINT, Toolkit::Align::CENTER )
  55     .Add( Toolkit::VisualProperty::Transform::Property::OFFSET_SIZE_MODE, Vector4::ZERO );
  56   return transformMap;
  57 }
  58
  59 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
  60 {
  61   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
  62   {
  63     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
  64     {
  65       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
  66
  67       Property::Value* valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
  68       if( NULL != valueSet )
  69       {
  70         if( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() )
  71         {
  72           tet_printf( "  Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
  73           return false;
  74         }
  75       }
  76       else
  77       {
  78         tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
  79         return false;
  80       }
  81     }
  82   }
  83
  84   return true;
  85 }
  86
  87 } //namespace
  88
  89 void dali_visual_startup(void)
  90 {
  91   test_return_value = TET_UNDEF;
  92 }
  93
  94 void dali_visual_cleanup(void)
  95 {
  96   test_return_value = TET_PASS;
  97 }
  98
  99 int UtcDaliVisualCopyAndAssignment(void)
 100 {
 101   ToolkitTestApplication application;
 102   tet_infoline( "UtcDaliVisualCopyAndAssignment" );
 103
 104   VisualFactory factory = VisualFactory::Get();
 105   Property::Map propertyMap;
 106   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 107   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 108   Visual::Base visual = factory.CreateVisual( propertyMap );
 109
 110   Visual::Base visualCopy( visual );
 111   DALI_TEST_CHECK(visual == visualCopy);
 112
 113   Visual::Base emptyVisual;
 114   Visual::Base emptyVisualCopy( emptyVisual );
 115   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 116
 117   Visual::Base visualEquals;
 118   visualEquals = visual;
 119   DALI_TEST_CHECK(visual == visualEquals);
 120
 121   Visual::Base emptyVisualEquals;
 122   emptyVisualEquals = emptyVisual;
 123   DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
 124
 125   //self assignment
 126   visual = visual;
 127   DALI_TEST_CHECK( visual = visualCopy );
 128
 129   END_TEST;
 130 }
 131
 132 int UtcDaliVisualSetName01(void)
 133 {
 134   ToolkitTestApplication application;
 135   tet_infoline( "UtcDaliVisualSetName" );
 136
 137   VisualFactory factory = VisualFactory::Get();
 138   Property::Map propertyMap;
 139   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 140   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 141   Visual::Base visual = factory.CreateVisual( propertyMap );
 142
 143   const char* visualName = "backgroundVisual";
 144   visual.SetName( visualName );
 145
 146   DALI_TEST_EQUALS( visual.GetName(), visualName, TEST_LOCATION );
 147
 148   END_TEST;
 149 }
 150
 151 int UtcDaliVisualSetGetDepthIndex(void)
 152 {
 153   ToolkitTestApplication application;
 154   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 155
 156   VisualFactory factory = VisualFactory::Get();
 157   Property::Map propertyMap;
 158   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 159   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 160   Visual::Base visual = factory.CreateVisual( propertyMap );
 161
 162   visual.SetDepthIndex( 1.f );
 163
 164   DummyControl dummyControl = DummyControl::New();
 165   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(dummyControl.GetImplementation());
 166   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 167
 168   dummyControl.SetSize(200.f, 200.f);
 169   Stage::GetCurrent().Add( dummyControl );
 170
 171
 172   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 173   DALI_TEST_EQUALS( depthIndex, 1, TEST_LOCATION );
 174   DALI_TEST_EQUALS( visual.GetDepthIndex(), 1.f, TEST_LOCATION );
 175
 176   visual.SetDepthIndex( -1.f );
 177   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 178   DALI_TEST_EQUALS( depthIndex, -1, TEST_LOCATION );
 179   DALI_TEST_EQUALS( visual.GetDepthIndex(), -1.f, TEST_LOCATION );
 180
 181   END_TEST;
 182 }
 183
 184 int UtcDaliVisualSize(void)
 185 {
 186   ToolkitTestApplication application;
 187   tet_infoline( "UtcDaliVisualGetNaturalSize" );
 188
 189   VisualFactory factory = VisualFactory::Get();
 190   Vector2 controlSize( 20.f, 30.f );
 191   Vector2 naturalSize;
 192
 193   // color colorVisual
 194   Dali::Property::Map map;
 195   map[ Visual::Property::TYPE ] = Visual::COLOR;
 196   map[ ColorVisual::Property::MIX_COLOR ] = Color::MAGENTA;
 197
 198   Visual::Base colorVisual = factory.CreateVisual( map );
 199   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 200
 201   colorVisual.GetNaturalSize(naturalSize);
 202   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 203
 204   // image visual
 205   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 206   Visual::Base imageVisual = factory.CreateVisual( image );
 207   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 208
 209   imageVisual.GetNaturalSize(naturalSize);
 210   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
 211
 212   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 213
 214   // border visual
 215   float borderSize = 5.f;
 216   map.Clear();
 217   map[ Visual::Property::TYPE ] = Visual::BORDER;
 218   map[ BorderVisual::Property::COLOR  ] = Color::RED;
 219   map[ BorderVisual::Property::SIZE   ] = borderSize;
 220   Visual::Base borderVisual = factory.CreateVisual( map );
 221   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 222   borderVisual.GetNaturalSize(naturalSize);
 223   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 224
 225   // gradient gradientVisual
 226   Property::Map propertyMap;
 227   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 228   Vector2 start(-1.f, -1.f);
 229   Vector2 end(1.f, 1.f);
 230   propertyMap.Insert(GradientVisual::Property::START_POSITION,   start);
 231   propertyMap.Insert(GradientVisual::Property::END_POSITION,   end);
 232   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.f, 1.f));
 233   Property::Array stopColors;
 234   stopColors.PushBack( Color::RED );
 235   stopColors.PushBack( Color::GREEN );
 236   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 237   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 238   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 239   gradientVisual.GetNaturalSize(naturalSize);
 240   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
 241
 242   // svg visual
 243   Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 244   svgVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 245   svgVisual.GetNaturalSize(naturalSize);
 246   // TEST_SVG_FILE:
 247   //  <svg width="100" height="100">
 248   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 249   //  </svg>
 250   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION );
 251
 252   // svg visual with a size
 253   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions(200, 200) );
 254   svgVisual2.GetNaturalSize(naturalSize);
 255   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
 256
 257   // Batch Image visual
 258   TestPlatformAbstraction& platform = application.GetPlatform();
 259   Vector2 testSize(80.f, 160.f);
 260   platform.SetClosestImageSize(testSize);
 261   propertyMap.Clear();
 262   propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
 263   propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
 264   propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
 265   Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
 266   batchImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 267   batchImageVisual.GetNaturalSize( naturalSize );
 268   DALI_TEST_EQUALS( naturalSize, Vector2( 80.0f, 160.0f ), TEST_LOCATION );
 269
 270   // Text visual.
 271
 272   // Load some fonts to get the same metrics on different platforms.
 273   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 274   fontClient.SetDpi( 96u, 96u );
 275
 276   char* pathNamePtr = get_current_dir_name();
 277   const std::string pathName( pathNamePtr );
 278   free( pathNamePtr );
 279
 280   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf" );
 281
 282   propertyMap.Clear();
 283   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
 284   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
 285   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
 286   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
 287
 288   Visual::Base textVisual = factory.CreateVisual( propertyMap );
 289   textVisual.GetNaturalSize( naturalSize );
 290   DALI_TEST_EQUALS( naturalSize, Size( 80.f, 20.f ), TEST_LOCATION );
 291
 292   const float height = textVisual.GetHeightForWidth( 40.f );
 293   DALI_TEST_EQUALS( height, 40.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 294
 295   END_TEST;
 296 }
 297
 298 int UtcDaliVisualSetOnOffStage(void)
 299 {
 300   ToolkitTestApplication application;
 301   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 302
 303   VisualFactory factory = VisualFactory::Get();
 304   Property::Map propertyMap;
 305   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 306   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 307   Visual::Base visual = factory.CreateVisual( propertyMap );
 308
 309   DummyControl actor = DummyControl::New();
 310   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 311   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 312
 313   actor.SetSize(200.f, 200.f);
 314
 315   application.SendNotification();
 316   application.Render(0);
 317   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 318
 319   Stage::GetCurrent().Add( actor );
 320
 321   application.SendNotification();
 322   application.Render(0);
 323   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 324
 325   Stage::GetCurrent().Remove( actor );
 326
 327   application.SendNotification();
 328   application.Render(0);
 329   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 330
 331   END_TEST;
 332 }
 333
 334
 335 int UtcDaliVisualGetPropertyMap1(void)
 336 {
 337   ToolkitTestApplication application;
 338   tet_infoline( "UtcDaliVisualGetPropertyMap1: ColorVisual" );
 339
 340   VisualFactory factory = VisualFactory::Get();
 341   Property::Map propertyMap;
 342   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 343   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 344   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 345
 346   Property::Map resultMap;
 347   colorVisual.CreatePropertyMap( resultMap );
 348
 349   Property::Value* typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 350   DALI_TEST_CHECK( typeValue );
 351   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 352
 353   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 354   DALI_TEST_CHECK( colorValue );
 355   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 356
 357   // change the blend color
 358   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 359   colorVisual = factory.CreateVisual( propertyMap  );
 360   colorVisual.CreatePropertyMap( resultMap );
 361
 362   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 363   DALI_TEST_CHECK( colorValue );
 364   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 365
 366   // Test the properties. TODO: to be completed.
 367   colorVisual.SetProperty( ColorVisual::Property::MIX_COLOR, Color::RED );
 368   Property::Value value = colorVisual.GetProperty( ColorVisual::Property::MIX_COLOR );
 369
 370   END_TEST;
 371 }
 372
 373 int UtcDaliVisualGetPropertyMap2(void)
 374 {
 375   ToolkitTestApplication application;
 376   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 377
 378   VisualFactory factory = VisualFactory::Get();
 379   Property::Map propertyMap;
 380   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 381   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
 382   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
 383   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 384
 385   Property::Map resultMap;
 386   borderVisual.CreatePropertyMap( resultMap );
 387
 388   // check the property values from the returned map from visual
 389   Property::Value* typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 390   DALI_TEST_CHECK( typeValue );
 391   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 392
 393   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 394   DALI_TEST_CHECK( colorValue );
 395   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 396
 397   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 398   DALI_TEST_CHECK( sizeValue );
 399   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 400
 401   Property::Map propertyMap1;
 402   propertyMap1[ Visual::Property::TYPE ] = Visual::BORDER;
 403   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 404   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 405   borderVisual = factory.CreateVisual( propertyMap1 );
 406   borderVisual.CreatePropertyMap( resultMap );
 407
 408   typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 409   DALI_TEST_CHECK( typeValue );
 410   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 411
 412   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 413   DALI_TEST_CHECK( colorValue );
 414   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 415
 416   colorValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 417   DALI_TEST_CHECK( colorValue );
 418   DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
 419
 420   // Test the properties. TODO: to be completed.
 421   borderVisual.SetProperty( BorderVisual::Property::COLOR, Color::RED );
 422   Property::Value value = borderVisual.GetProperty( BorderVisual::Property::COLOR );
 423
 424   END_TEST;
 425 }
 426
 427 int UtcDaliVisualGetPropertyMap3(void)
 428 {
 429   ToolkitTestApplication application;
 430   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 431
 432   VisualFactory factory = VisualFactory::Get();
 433   DALI_TEST_CHECK( factory );
 434
 435   Property::Map propertyMap;
 436   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 437
 438   Vector2 start(-1.f, -1.f);
 439   Vector2 end(1.f, 1.f);
 440   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
 441   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
 442   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 443
 444   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 445
 446   Property::Array stopColors;
 447   stopColors.PushBack( Color::RED );
 448   stopColors.PushBack( Color::GREEN );
 449   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 450
 451   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 452
 453   Property::Map resultMap;
 454   gradientVisual.CreatePropertyMap( resultMap );
 455
 456   // check the property values from the returned map from visual
 457   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 458   DALI_TEST_CHECK( value );
 459   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 460
 461   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 462   DALI_TEST_CHECK( value );
 463   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 464
 465   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 466   DALI_TEST_CHECK( value );
 467   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 468
 469   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 470   DALI_TEST_CHECK( value );
 471   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 472
 473   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 474   DALI_TEST_CHECK( value );
 475   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 476
 477   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 478   DALI_TEST_CHECK( value );
 479   Property::Array* offsetArray = value->GetArray();
 480   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 481   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 482   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 483
 484   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 485   DALI_TEST_CHECK( value );
 486   Property::Array* colorArray = value->GetArray();
 487   DALI_TEST_CHECK( colorArray->Count() == 2 );
 488   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 489   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 490
 491   // Test the properties. TODO: to be completed.
 492   gradientVisual.SetProperty( GradientVisual::Property::STOP_COLOR, Color::RED );
 493   Property::Value gradientValue = gradientVisual.GetProperty( GradientVisual::Property::STOP_COLOR );
 494
 495   END_TEST;
 496 }
 497
 498 int UtcDaliVisualGetPropertyMap4(void)
 499 {
 500   ToolkitTestApplication application;
 501   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 502
 503   VisualFactory factory = VisualFactory::Get();
 504   DALI_TEST_CHECK( factory );
 505
 506   Property::Map propertyMap;
 507   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 508
 509   Vector2 center(100.f, 100.f);
 510   float radius = 100.f;
 511   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 512   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 513   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 514   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 515
 516   Property::Array stopColors;
 517   stopColors.PushBack( Color::RED );
 518   stopColors.PushBack( Color::BLACK );
 519   stopColors.PushBack( Color::GREEN );
 520   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 521
 522   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 523   DALI_TEST_CHECK( gradientVisual );
 524
 525   Property::Map resultMap;
 526   gradientVisual.CreatePropertyMap( resultMap );
 527
 528   // check the property values from the returned map from visual
 529   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 530   DALI_TEST_CHECK( value );
 531   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 532
 533   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 534   DALI_TEST_CHECK( value );
 535   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 536
 537   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 538   DALI_TEST_CHECK( value );
 539   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 540
 541   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 542   DALI_TEST_CHECK( value );
 543   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 544
 545   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 546   DALI_TEST_CHECK( value );
 547   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 548
 549   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 550   DALI_TEST_CHECK( value );
 551   Property::Array* offsetArray = value->GetArray();
 552   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 553   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 554   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 555   // any stop value will be clamped to [0.0, 1.0];
 556   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 557
 558   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 559   DALI_TEST_CHECK( value );
 560   Property::Array* colorArray = value->GetArray();
 561   DALI_TEST_CHECK( colorArray->Count() == 3 );
 562   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 563   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 564   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 565
 566   END_TEST;
 567 }
 568
 569 int UtcDaliVisualGetPropertyMap5(void)
 570 {
 571   ToolkitTestApplication application;
 572   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 573
 574   VisualFactory factory = VisualFactory::Get();
 575   Property::Map propertyMap;
 576   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
 577   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 578   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 579   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 580   propertyMap.Insert( ImageVisual::Property::FITTING_MODE,   FittingMode::FIT_HEIGHT );
 581   propertyMap.Insert( ImageVisual::Property::SAMPLING_MODE,   SamplingMode::BOX_THEN_NEAREST );
 582   propertyMap.Insert( ImageVisual::Property::PIXEL_AREA, Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 583   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_U, WrapMode::REPEAT );
 584   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_V, WrapMode::MIRRORED_REPEAT );
 585   propertyMap.Insert( "synchronousLoading",   true );
 586
 587   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 588   DALI_TEST_CHECK( imageVisual );
 589
 590   Property::Map resultMap;
 591   imageVisual.CreatePropertyMap( resultMap );
 592
 593   // check the property values from the returned map from visual
 594   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 595   DALI_TEST_CHECK( value );
 596   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 597
 598   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 599   DALI_TEST_CHECK( value );
 600   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 601
 602   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 603   DALI_TEST_CHECK( value );
 604   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 605
 606   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 607   DALI_TEST_CHECK( value );
 608   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX_THEN_NEAREST );
 609
 610   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 611   DALI_TEST_CHECK( value );
 612   DALI_TEST_CHECK( value->Get<int>() == 20 );
 613
 614   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 615   DALI_TEST_CHECK( value );
 616   DALI_TEST_CHECK( value->Get<int>() == 30 );
 617
 618   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 619   DALI_TEST_CHECK( value );
 620   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.25f, 0.25f, 0.5f, 0.5f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 621
 622   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 623   DALI_TEST_CHECK( value );
 624   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::REPEAT);
 625
 626   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 627   DALI_TEST_CHECK( value );
 628   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 629
 630   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 631   DALI_TEST_CHECK( value );
 632   DALI_TEST_CHECK( value->Get<bool>() == true );
 633
 634   // Get an image visual with an image handle, and test the default property values
 635   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 636   imageVisual = factory.CreateVisual(image);
 637   imageVisual.CreatePropertyMap( resultMap );
 638
 639   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 640   DALI_TEST_CHECK( value );
 641   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 642
 643   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 644   DALI_TEST_CHECK( value );
 645   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 646
 647   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 648   DALI_TEST_CHECK( value );
 649   DALI_TEST_CHECK( value->Get<int>() == FittingMode::SHRINK_TO_FIT );
 650
 651   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 652   DALI_TEST_CHECK( value );
 653   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX );
 654
 655   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 656   DALI_TEST_CHECK( value );
 657   DALI_TEST_CHECK( value->Get<int>() == 100 );
 658
 659   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 660   DALI_TEST_CHECK( value );
 661   DALI_TEST_CHECK( value->Get<int>() == 200 );
 662
 663   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 664   DALI_TEST_CHECK( value );
 665   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.f, 0.f, 1.f, 1.f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 666
 667   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 668   DALI_TEST_CHECK( value );
 669   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 670
 671   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 672   DALI_TEST_CHECK( value );
 673   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 674
 675   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 676   DALI_TEST_CHECK( value );
 677   DALI_TEST_CHECK( value->Get<bool>() == false );
 678
 679   END_TEST;
 680 }
 681
 682 int UtcDaliVisualGetPropertyMap6(void)
 683 {
 684   ToolkitTestApplication application;
 685   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 686
 687   VisualFactory factory = VisualFactory::Get();
 688   Property::Map propertyMap;
 689   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
 690   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 691   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 692   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 693
 694   Property::Map resultMap;
 695   nPatchVisual.CreatePropertyMap( resultMap );
 696
 697   // check the property values from the returned map from visual
 698   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 699   DALI_TEST_CHECK( value );
 700   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 701
 702   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 703   DALI_TEST_CHECK( value );
 704   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 705
 706   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 707   DALI_TEST_CHECK( value );
 708   DALI_TEST_CHECK( value->Get<bool>() );
 709
 710
 711   END_TEST;
 712 }
 713
 714 int UtcDaliVisualGetPropertyMap7(void)
 715 {
 716   ToolkitTestApplication application;
 717   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 718
 719   // request SvgVisual with a property map
 720   VisualFactory factory = VisualFactory::Get();
 721   Property::Map propertyMap;
 722   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
 723   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 724   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 725
 726   Property::Map resultMap;
 727   svgVisual.CreatePropertyMap( resultMap );
 728   // check the property values from the returned map from a visual
 729   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 730   DALI_TEST_CHECK( value );
 731   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 732
 733   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 734   DALI_TEST_CHECK( value );
 735   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 736
 737   // request SvgVisual with an URL
 738   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 739   resultMap.Clear();
 740   svgVisual2.CreatePropertyMap( resultMap );
 741   // check the property values from the returned map from a visual
 742   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 743   DALI_TEST_CHECK( value );
 744   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 745
 746   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 747   DALI_TEST_CHECK( value );
 748   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 749
 750   // Test the properties. TODO: to be completed.
 751   svgVisual.SetProperty( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 752   Property::Value svgValue = svgVisual.GetProperty( ImageVisual::Property::URL );
 753
 754   END_TEST;
 755 }
 756
 757 //Mesh visual
 758 int UtcDaliVisualGetPropertyMap8(void)
 759 {
 760   ToolkitTestApplication application;
 761   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
 762
 763   //Request MeshVisual using a property map.
 764   VisualFactory factory = VisualFactory::Get();
 765   Property::Map propertyMap;
 766   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
 767   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
 768   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
 769   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
 770   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
 771   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 772   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
 773
 774   Property::Map resultMap;
 775   meshVisual.CreatePropertyMap( resultMap );
 776
 777   //Check values in the result map are identical to the initial map's values.
 778   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 779   DALI_TEST_CHECK( value );
 780   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
 781
 782   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
 783   DALI_TEST_CHECK( value );
 784   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
 785
 786   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
 787   DALI_TEST_CHECK( value );
 788   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
 789
 790   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
 791   DALI_TEST_CHECK( value );
 792   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
 793
 794   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
 795   DALI_TEST_CHECK( value );
 796   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
 797
 798   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 799   DALI_TEST_CHECK( value );
 800   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 801
 802   // Test the properties. TODO: to be completed.
 803   meshVisual.SetProperty( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
 804   Property::Value meshValue = meshVisual.GetProperty( MeshVisual::Property::OBJECT_URL );
 805
 806   END_TEST;
 807 }
 808
 809 //Primitive shape visual
 810 int UtcDaliVisualGetPropertyMap9(void)
 811 {
 812   ToolkitTestApplication application;
 813   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
 814
 815   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
 816   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
 817
 818   //Request PrimitiveVisual using a property map.
 819   VisualFactory factory = VisualFactory::Get();
 820   Property::Map propertyMap;
 821   propertyMap.Insert( Visual::Property::TYPE, Visual::PRIMITIVE );
 822   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
 823   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
 824   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
 825   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
 826   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
 827   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
 828   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
 829   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
 830   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
 831   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
 832   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
 833   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 834   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
 835
 836   Property::Map resultMap;
 837   primitiveVisual.CreatePropertyMap( resultMap );
 838
 839   //Check values in the result map are identical to the initial map's values.
 840   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 841   DALI_TEST_CHECK( value );
 842   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
 843
 844   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
 845   DALI_TEST_CHECK( value );
 846   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
 847
 848   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
 849   DALI_TEST_CHECK( value );
 850   DALI_TEST_CHECK( value->Get<Vector4>() == color );
 851   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 852
 853   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
 854   DALI_TEST_CHECK( value );
 855   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
 856
 857   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
 858   DALI_TEST_CHECK( value );
 859   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
 860
 861   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
 862   DALI_TEST_CHECK( value );
 863   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 864
 865   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
 866   DALI_TEST_CHECK( value );
 867   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 868
 869   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
 870   DALI_TEST_CHECK( value );
 871   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 872
 873   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
 874   DALI_TEST_CHECK( value );
 875   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 876
 877   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
 878   DALI_TEST_CHECK( value );
 879   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 880
 881   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
 882   DALI_TEST_CHECK( value );
 883   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 884
 885   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
 886   DALI_TEST_CHECK( value );
 887   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 888
 889   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 890   DALI_TEST_CHECK( value );
 891   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 892
 893   // Test the properties. TODO: to be completed.
 894   primitiveVisual.SetProperty( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
 895   Property::Value primitiveValue = primitiveVisual.GetProperty( PrimitiveVisual::Property::SHAPE );
 896
 897   END_TEST;
 898 }
 899
 900 int UtcDaliVisualGetPropertyMapBatchImageVisual(void)
 901 {
 902   ToolkitTestApplication application;
 903   tet_infoline( "UtcDaliVisualGetPropertyMapBatchImageVisual:" );
 904
 905   VisualFactory factory = VisualFactory::Get();
 906   Property::Map propertyMap;
 907   propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
 908   propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
 909   propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
 910   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
 911   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
 912
 913   Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
 914   DALI_TEST_CHECK( batchImageVisual );
 915
 916   Property::Map resultMap;
 917   batchImageVisual.CreatePropertyMap( resultMap );
 918
 919   // Check the property values from the returned map from visual
 920   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 921   DALI_TEST_CHECK( value );
 922   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 923
 924   value = resultMap.Find( ImageVisual::Property::URL, Property::STRING );
 925   DALI_TEST_CHECK( value );
 926   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 927
 928   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER );
 929   DALI_TEST_CHECK( value );
 930   DALI_TEST_CHECK( value->Get<int>() == 20 );
 931
 932   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER );
 933   DALI_TEST_CHECK( value );
 934   DALI_TEST_CHECK( value->Get<int>() == 30 );
 935
 936   // Test the properties. TODO: to be completed.
 937   batchImageVisual.SetProperty( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
 938   Property::Value primitiveValue = batchImageVisual.GetProperty( ImageVisual::Property::URL );
 939
 940   END_TEST;
 941 }
 942
 943 //Text shape visual
 944 int UtcDaliVisualGetPropertyMap10(void)
 945 {
 946   ToolkitTestApplication application;
 947   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
 948
 949   //Request PrimitiveVisual using a property map.
 950   VisualFactory factory = VisualFactory::Get();
 951
 952   Property::Map propertyMap;
 953   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
 954   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
 955   propertyMap.Insert( "text", "Hello world" );
 956   propertyMap.Insert( "fontFamily", "TizenSans" );
 957
 958   Property::Map fontStyleMapSet;
 959   fontStyleMapSet.Insert( "weight", "bold" );
 960   propertyMap.Insert( "fontStyle", fontStyleMapSet );
 961
 962   propertyMap.Insert( "pointSize", 12.f );
 963   propertyMap.Insert( "multiLine", true );
 964   propertyMap.Insert( "horizontalAlignment", "CENTER" );
 965   propertyMap.Insert( "verticalAlignment", "CENTER" );
 966   propertyMap.Insert( "textColor", Color::RED );
 967   propertyMap.Insert( "enableMarkup", false );
 968   Visual::Base textVisual = factory.CreateVisual( propertyMap );
 969
 970   Property::Map resultMap;
 971   textVisual.CreatePropertyMap( resultMap );
 972
 973   //Check values in the result map are identical to the initial map's values.
 974   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 975   DALI_TEST_CHECK( value );
 976   DALI_TEST_EQUALS( value->Get<int>(), (int)DevelVisual::TEXT, TEST_LOCATION );
 977
 978   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
 979   DALI_TEST_CHECK( value );
 980   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
 981
 982   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
 983   DALI_TEST_CHECK( value );
 984   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
 985
 986   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
 987   DALI_TEST_CHECK( value );
 988
 989   Property::Map fontStyleMapGet = value->Get<Property::Map>();
 990   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
 991   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
 992
 993   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
 994   DALI_TEST_CHECK( value );
 995   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 996
 997   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
 998   DALI_TEST_CHECK( value );
 999   DALI_TEST_CHECK( value->Get<bool>() );
1000
1001   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::STRING );
1002   DALI_TEST_CHECK( value );
1003   DALI_TEST_EQUALS( value->Get<std::string>(), "CENTER", TEST_LOCATION );
1004
1005   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::STRING );
1006   DALI_TEST_CHECK( value );
1007   DALI_TEST_EQUALS( value->Get<std::string>(), "CENTER", TEST_LOCATION );
1008
1009   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1010   DALI_TEST_CHECK( value );
1011   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1012
1013   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1014   DALI_TEST_CHECK( value );
1015   DALI_TEST_CHECK( !value->Get<bool>() );
1016
1017   END_TEST;
1018 }
1019
1020 int UtcDaliVisualGetPropertyMapBatchImageVisualNoAtlas(void)
1021 {
1022   ToolkitTestApplication application;
1023   tet_infoline( "UtcDaliVisualGetPropertyMapBatchImageVisualNoAtlas:" );
1024
1025   VisualFactory factory = VisualFactory::Get();
1026   Property::Map propertyMap;
1027   propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
1028   propertyMap.Insert( ImageVisual::Property::BATCHING_ENABLED, true );
1029   propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
1030
1031   // Set the desired size to be larger than the atlas limit of 1024x1024.
1032   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 2048 );
1033   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 2048 );
1034
1035   // Create the visual.
1036   Visual::Base batchImageVisual = factory.CreateVisual( propertyMap );
1037
1038   DALI_TEST_CHECK( batchImageVisual );
1039
1040   DummyControl dummyControl = DummyControl::New();
1041   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(dummyControl.GetImplementation());
1042   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, batchImageVisual );
1043   Stage::GetCurrent().Add( dummyControl );
1044
1045   DALI_TEST_CHECK( dummyControl.GetRendererCount() == 1u );
1046
1047   END_TEST;
1048 }
1049
1050 int UtcDaliVisualAnimateBorderVisual01(void)
1051 {
1052   ToolkitTestApplication application;
1053   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1054
1055   VisualFactory factory = VisualFactory::Get();
1056   Property::Map propertyMap;
1057   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1058   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1059   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1060   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1061
1062   DummyControl actor = DummyControl::New();
1063   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1064   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, borderVisual );
1065   actor.SetSize(2000, 2000);
1066   actor.SetParentOrigin(ParentOrigin::CENTER);
1067   Stage::GetCurrent().Add(actor);
1068
1069   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1070
1071   Renderer renderer = actor.GetRendererAt(0);
1072   Property::Index index = renderer.GetPropertyIndex( BorderVisual::Property::COLOR );
1073
1074   Animation animation = Animation::New(4.0f);
1075   animation.AnimateTo( Property(renderer, index), Color::WHITE );
1076   animation.Play();
1077
1078   application.SendNotification();
1079   application.Render(0);
1080   application.Render(2000u); // halfway point between blue and white
1081
1082   Vector4 color = renderer.GetProperty<Vector4>( index );
1083   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1084   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1085   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1086
1087   application.Render(2000u); // halfway point between blue and white
1088
1089   color = renderer.GetProperty<Vector4>( index );
1090   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1091   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1092
1093   END_TEST;
1094 }
1095
1096
1097 int UtcDaliVisualAnimateBorderVisual02(void)
1098 {
1099   ToolkitTestApplication application;
1100   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1101
1102   VisualFactory factory = VisualFactory::Get();
1103   Property::Map propertyMap;
1104   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1105   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1106   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1107   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1108
1109   DummyControl actor = DummyControl::New();
1110   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1111   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, borderVisual );
1112   actor.SetSize(2000, 2000);
1113   actor.SetParentOrigin(ParentOrigin::CENTER);
1114   Stage::GetCurrent().Add(actor);
1115
1116   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1117
1118   Renderer renderer = actor.GetRendererAt(0);
1119   Property::Index index = renderer.GetPropertyIndex( BorderVisual::Property::SIZE );
1120
1121   Animation animation = Animation::New(4.0f);
1122   animation.AnimateTo( Property(renderer, index), 9.0f );
1123   animation.Play();
1124
1125   application.SendNotification();
1126   application.Render(0);
1127   application.Render(2000u); // halfway point
1128
1129   float size = renderer.GetProperty<float>( index );
1130   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1131   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1132
1133   application.Render(2000u); // halfway point between blue and white
1134
1135   size = renderer.GetProperty<float>( index );
1136   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1137   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1138
1139   END_TEST;
1140 }
1141
1142 int UtcDaliVisualAnimateColorVisual(void)
1143 {
1144   ToolkitTestApplication application;
1145   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1146
1147   VisualFactory factory = VisualFactory::Get();
1148   Property::Map propertyMap;
1149   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1150   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1151   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1152
1153   DummyControl actor = DummyControl::New();
1154   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1155   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, borderVisual );
1156   actor.SetSize(2000, 2000);
1157   actor.SetParentOrigin(ParentOrigin::CENTER);
1158   Stage::GetCurrent().Add(actor);
1159
1160   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1161
1162   Renderer renderer = actor.GetRendererAt(0);
1163   Property::Index index = renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1164
1165   Animation animation = Animation::New(4.0f);
1166   animation.AnimateTo( Property(renderer, index), Color::WHITE );
1167   animation.Play();
1168
1169   application.SendNotification();
1170   application.Render(0);
1171   application.Render(2000u); // halfway point
1172
1173   Vector4 color = renderer.GetProperty<Vector4>( index );
1174   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1175   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1176
1177   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", testColor ), true, TEST_LOCATION );
1178
1179   application.Render(2000u); // halfway point between blue and white
1180
1181   color = renderer.GetProperty<Vector4>( index );
1182   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1183
1184   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("mixColor", Color::WHITE ), true, TEST_LOCATION );
1185
1186
1187   END_TEST;
1188 }
1189
1190
1191 int UtcDaliVisualAnimatePrimitiveVisual(void)
1192 {
1193   ToolkitTestApplication application;
1194   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1195
1196   VisualFactory factory = VisualFactory::Get();
1197   Property::Map propertyMap;
1198   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1199   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1200   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1201
1202   DummyControl actor = DummyControl::New();
1203   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1204   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, borderVisual );
1205   actor.SetSize(2000, 2000);
1206   actor.SetParentOrigin(ParentOrigin::CENTER);
1207   actor.SetColor(Color::BLACK);
1208   Stage::GetCurrent().Add(actor);
1209
1210   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1211
1212   Renderer renderer = actor.GetRendererAt(0);
1213   Property::Index index = renderer.GetPropertyIndex( PrimitiveVisual::Property::MIX_COLOR );
1214
1215   // The property isn't registered on the renderer, it's instead registered on the shader.
1216   DALI_TEST_EQUALS( index, Property::INVALID_INDEX, TEST_LOCATION );
1217
1218   Animation animation = Animation::New(4.0f);
1219   animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1220   animation.Play();
1221
1222   application.SendNotification();
1223   application.Render(0);
1224   application.Render(2000u); // halfway point
1225
1226   // Actor color overrides renderer color.
1227   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
1228
1229   application.Render(2000u); // halfway point between blue and white
1230
1231   DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1232   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
1233
1234
1235   END_TEST;
1236 }
1237
1238 int UtcDaliVisualWireframeVisual(void)
1239 {
1240   ToolkitTestApplication application;
1241
1242   VisualFactory factory = VisualFactory::Get();
1243   Property::Map propertyMap;
1244   propertyMap.Insert( Visual::Property::TYPE, Visual::WIREFRAME );
1245
1246   // Create the visual.
1247   Visual::Base visual = factory.CreateVisual( propertyMap );
1248
1249   DALI_TEST_CHECK( visual );
1250
1251   Property::Map resultMap;
1252   visual.CreatePropertyMap( resultMap );
1253
1254   // Check the property values from the returned map from visual
1255   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
1256   DALI_TEST_CHECK( value );
1257   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
1258
1259   // Test the properties. TODO: to be completed.
1260   Property::Value primitiveValue = visual.GetProperty( Visual::Property::TYPE );
1261
1262   END_TEST;
1263 }
1264
1265 int UtcDaliVisualGetTransform(void)
1266 {
1267   ToolkitTestApplication application;
1268   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
1269
1270   VisualFactory factory = VisualFactory::Get();
1271   Property::Map propertyMap;
1272   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1273   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1274   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
1275
1276   Dali::Property::Map map;
1277   Dali::Property::Value transformProperty = colorVisual.GetProperty( Dali::Toolkit::Visual::DevelProperty::TRANSFORM );
1278   transformProperty.Get(map);
1279
1280   //Test default values
1281   {
1282     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::OFFSET );
1283     DALI_TEST_CHECK( typeValue );
1284     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
1285   }
1286   {
1287     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::SIZE );
1288     DALI_TEST_CHECK( typeValue );
1289     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
1290   }
1291   {
1292     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::OFFSET_SIZE_MODE );
1293     DALI_TEST_CHECK( typeValue );
1294     DALI_TEST_CHECK( typeValue->Get<Vector4>() == Vector4(0.0f,0.0f,0.0f,0.0f) );
1295   }
1296   {
1297     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::ORIGIN );
1298     DALI_TEST_CHECK( typeValue );
1299     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::CENTER );
1300   }
1301   {
1302     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::ANCHOR_POINT );
1303     DALI_TEST_CHECK( typeValue );
1304     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::CENTER );
1305   }
1306
1307   END_TEST;
1308 }
1309
1310 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
1311 {
1312   Property::Map transform;
1313   transform.Insert( Visual::DevelProperty::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
1314   transform.Insert( Visual::DevelProperty::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
1315   transform.Insert( Visual::DevelProperty::Transform::Property::OFFSET_SIZE_MODE, Vector4(1.0f, 1.0f, 0.0f,0.0f) );
1316   transform.Insert( Visual::DevelProperty::Transform::Property::ORIGIN, "TOP_BEGIN" );
1317   transform.Insert( Visual::DevelProperty::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
1318
1319   visual.SetProperty( Dali::Toolkit::Visual::DevelProperty::TRANSFORM, transform );
1320
1321   Dali::Property::Map map;
1322   Dali::Property::Value transformProperty = visual.GetProperty( Dali::Toolkit::Visual::DevelProperty::TRANSFORM );
1323   transformProperty.Get(map);
1324
1325   {
1326     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::OFFSET );
1327     DALI_TEST_CHECK( typeValue );
1328     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
1329   }
1330   {
1331     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::SIZE );
1332     DALI_TEST_CHECK( typeValue );
1333     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
1334   }
1335   {
1336     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::OFFSET_SIZE_MODE );
1337     DALI_TEST_CHECK( typeValue );
1338     DALI_TEST_EQUALS( typeValue->Get<Vector4>(), Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1339   }
1340   {
1341     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::ORIGIN );
1342     DALI_TEST_CHECK( typeValue );
1343     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::TOP_BEGIN, TEST_LOCATION );
1344   }
1345   {
1346     Property::Value* typeValue = map.Find( Toolkit::Visual::DevelProperty::Transform::Property::ANCHOR_POINT );
1347     DALI_TEST_CHECK( typeValue );
1348     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
1349   }
1350
1351   //Put the visual on the stage
1352   DummyControl actor = DummyControl::New();
1353   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1354   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1355   actor.SetSize(2000, 2000);
1356   actor.SetParentOrigin(ParentOrigin::CENTER);
1357   Stage::GetCurrent().Add(actor);
1358
1359   application.SendNotification();
1360   application.Render(0);
1361   Renderer renderer( actor.GetRendererAt(0) );
1362
1363   //Check that the properties have been registered on the Renderer
1364   Vector2 offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1365   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
1366
1367   Vector2 size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1368   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
1369
1370   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1371   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1372
1373   Vector2 parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1374   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1375
1376   Vector2 anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1377   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1378
1379   //Set a new transform
1380   transform.Clear();
1381   transform.Insert( Visual::DevelProperty::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
1382   transform.Insert( Visual::DevelProperty::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
1383   transform.Insert( Visual::DevelProperty::Transform::Property::OFFSET_SIZE_MODE, Vector4(0.0f, 0.0f, 1.0f,1.0f) );
1384   visual.SetProperty( Dali::Toolkit::Visual::DevelProperty::TRANSFORM, transform );
1385   application.SendNotification();
1386   application.Render(0);
1387
1388   //Check that the values have changed in the renderer
1389   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1390   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
1391
1392   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1393   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
1394
1395   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1396   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
1397
1398   //Parent origin and anchor point should have default values
1399   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1400   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
1401
1402   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1403   DALI_TEST_EQUALS( anchorPoint, Vector2(0.0f,0.0f), TEST_LOCATION );
1404 }
1405
1406 int UtcDaliVisualSetTransform0(void)
1407 {
1408   ToolkitTestApplication application;
1409   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
1410
1411   VisualFactory factory = VisualFactory::Get();
1412   Property::Map propertyMap;
1413   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1414   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1415   Visual::Base visual = factory.CreateVisual( propertyMap );
1416   TestTransform( application, visual );
1417
1418   END_TEST;
1419 }
1420
1421 int UtcDaliVisualSetTransform1(void)
1422 {
1423   ToolkitTestApplication application;
1424   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
1425
1426   VisualFactory factory = VisualFactory::Get();
1427   Property::Map propertyMap;
1428   propertyMap[ Visual::Property::TYPE           ] = Visual::PRIMITIVE;
1429   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Vector4(1.0f,1.0f,1.0f,1.0f);
1430   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
1431   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
1432   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
1433   Visual::Base visual = factory.CreateVisual( propertyMap );
1434   TestTransform( application, visual );
1435
1436   END_TEST;
1437 }
1438
1439 int UtcDaliVisualSetTransform2(void)
1440 {
1441   ToolkitTestApplication application;
1442   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
1443
1444   VisualFactory factory = VisualFactory::Get();
1445   Property::Map propertyMap;
1446   propertyMap.Insert( Visual::Property::TYPE,  Visual::GRADIENT );
1447   Property::Array stopOffsets;
1448   stopOffsets.PushBack( 0.0f );
1449   stopOffsets.PushBack( 0.3f );
1450   stopOffsets.PushBack( 0.6f );
1451   stopOffsets.PushBack( 0.8f );
1452   stopOffsets.PushBack( 1.0f );
1453   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
1454
1455   Property::Array stopColors;
1456   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
1457   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
1458   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
1459   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
1460   stopColors.PushBack( Color::YELLOW );
1461   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
1462   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
1463   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
1464   Visual::Base visual = factory.CreateVisual( propertyMap );
1465   TestTransform( application, visual );
1466
1467   END_TEST;
1468 }
1469
1470 int UtcDaliVisualSetTransform3(void)
1471 {
1472   ToolkitTestApplication application;
1473   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
1474
1475   VisualFactory factory = VisualFactory::Get();
1476   Property::Map propertyMap;
1477   propertyMap.Insert( Visual::Property::TYPE, Visual::BORDER );
1478   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
1479   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
1480   Visual::Base visual = factory.CreateVisual( propertyMap );
1481   TestTransform( application, visual );
1482
1483   END_TEST;
1484 }
1485
1486 int UtcDaliVisualSetTransform4(void)
1487 {
1488   ToolkitTestApplication application;
1489   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
1490
1491   VisualFactory factory = VisualFactory::Get();
1492   Property::Map propertyMap;
1493   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
1494   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1495   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1496   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
1497   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1498   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
1499   Visual::Base visual = factory.CreateVisual( propertyMap );
1500   TestTransform( application, visual );
1501
1502   END_TEST;
1503 }
1504
1505 int UtcDaliVisualSetTransform5(void)
1506 {
1507   ToolkitTestApplication application;
1508   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
1509
1510   VisualFactory factory = VisualFactory::Get();
1511   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
1512   Visual::Base visual = factory.CreateVisual(image);
1513   TestTransform( application, visual );
1514
1515   END_TEST;
1516 }
1517
1518 int UtcDaliVisualSetTransform6(void)
1519 {
1520   ToolkitTestApplication application;
1521   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
1522
1523   VisualFactory factory = VisualFactory::Get();
1524   Property::Map propertyMap;
1525   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
1526   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1527   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
1528   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
1529   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
1530   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
1531   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
1532   Visual::Base visual = factory.CreateVisual(propertyMap);
1533   TestTransform( application, visual );
1534
1535   END_TEST;
1536 }
1537
1538 int UtcDaliVisualSetTransform7(void)
1539 {
1540   ToolkitTestApplication application;
1541   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
1542
1543   VisualFactory factory = VisualFactory::Get();
1544   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
1545   Visual::Base visual = factory.CreateVisual(image);
1546   TestTransform( application, visual );
1547
1548   END_TEST;
1549 }
1550
1551 int UtcDaliNPatchVisualCustomShader(void)
1552 {
1553   ToolkitTestApplication application;
1554   tet_infoline( "NPatchVisual with custom shader" );
1555
1556   VisualFactory factory = VisualFactory::Get();
1557   Property::Map properties;
1558   Property::Map shader;
1559   const std::string fragmentShader = "Foobar";
1560   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
1561   properties[Dali::Toolkit::Visual::Property::TYPE] = Dali::Toolkit::Visual::IMAGE;
1562   properties[Dali::Toolkit::Visual::Property::SHADER]=shader;
1563   properties[Dali::Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
1564
1565   Visual::Base visual = factory.CreateVisual( properties );
1566
1567   // trigger creation through setting on stage
1568   DummyControl dummy = DummyControl::New();
1569   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(dummy.GetImplementation());
1570   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1571   dummy.SetSize(2000, 2000);
1572   dummy.SetParentOrigin(ParentOrigin::CENTER);
1573   Stage::GetCurrent().Add(dummy);
1574
1575   Renderer renderer = dummy.GetRendererAt( 0 );
1576   Shader shader2 = renderer.GetShader();
1577   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
1578   Property::Map* map = value.GetMap();
1579   DALI_TEST_CHECK( map );
1580
1581   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
1582   // *map["vertex"]; is default here so not verifying it
1583
1584   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
1585
1586   END_TEST;
1587 }
1588 int UtcDaliGradientVisualBlendMode(void)
1589 {
1590   ToolkitTestApplication application;
1591   VisualFactory factory = VisualFactory::Get();
1592
1593   Visual::Base opaqueGradientVisual = factory.CreateVisual(
1594       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1595                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1596                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1597                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1598                                                                                   .Add( Color::GREEN ) ) );
1599
1600   Visual::Base alphaGradientVisual = factory.CreateVisual(
1601       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1602                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1603                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1604                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1605                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
1606
1607   DummyControl control = DummyControl::New();
1608   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1609   Stage::GetCurrent().Add( control );
1610
1611   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>( control.GetImplementation() );
1612   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, opaqueGradientVisual );
1613   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 2, alphaGradientVisual );
1614
1615   application.SendNotification();
1616   application.Render();
1617
1618   // 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
1619   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
1620   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
1621   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1622
1623   END_TEST;
1624 }
1625
1626 int UtcDaliVisualRendererRemovalAndReAddition(void)
1627 {
1628   ToolkitTestApplication application;
1629   tet_infoline( "UtcDaliVisualRendererRemoval" );
1630
1631   VisualFactory factory = VisualFactory::Get();
1632   Property::Map propertyMap;
1633   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1634   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1635   Visual::Base visual = factory.CreateVisual( propertyMap );
1636
1637   visual.SetDepthIndex( 1.f );
1638
1639   DummyControl dummyControl = DummyControl::New();
1640   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(dummyControl.GetImplementation());
1641   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1642   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1643
1644   dummyControl.SetSize(200.f, 200.f);
1645   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
1646
1647   Stage::GetCurrent().Add( dummyControl );
1648
1649   application.SendNotification();
1650   application.Render();
1651
1652   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1653
1654   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
1655   Stage::GetCurrent().Remove( dummyControl );
1656   application.SendNotification();
1657   application.Render();
1658
1659   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1660
1661   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
1662
1663   Stage::GetCurrent().Add( dummyControl );
1664
1665   application.SendNotification();
1666   application.Render();
1667
1668   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1669
1670   END_TEST;
1671 }
1672
1673
1674
1675 int UtcDaliVisualTextVisualRender(void)
1676 {
1677   ToolkitTestApplication application;
1678   tet_infoline( "UtcDaliVisualTextVisualRender" );
1679
1680   VisualFactory factory = VisualFactory::Get();
1681   Property::Map propertyMap;
1682   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1683   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1684   propertyMap.Insert( "text", "Hello world" );
1685   propertyMap.Insert( "fontFamily", "TizenSans" );
1686
1687   Property::Map fontStyleMapSet;
1688   fontStyleMapSet.Insert( "weight", "bold" );
1689   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1690
1691   propertyMap.Insert( "pointSize", 12.f );
1692   propertyMap.Insert( "multiLine", true );
1693   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1694   propertyMap.Insert( "verticalAlignment", "CENTER" );
1695   propertyMap.Insert( "textColor", Color::RED );
1696   propertyMap.Insert( "enableMarkup", false );
1697   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1698   textVisual.SetDepthIndex( 1.f );
1699
1700   DummyControl dummyControl = DummyControl::New(true);
1701   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(dummyControl.GetImplementation());
1702   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, textVisual );
1703   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1704
1705   dummyControl.SetSize(200.f, 200.f);
1706
1707   Stage::GetCurrent().Add( dummyControl );
1708   application.SendNotification();
1709   application.Render();
1710
1711   END_TEST;
1712 }