2 * Copyright (c) 2024 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include <dali-toolkit-test-suite-utils.h>
22 #include <dali-toolkit/dali-toolkit.h>
23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
24 #include <dali-toolkit/devel-api/controls/control-devel.h>
25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
29 #include <dali-toolkit/devel-api/visuals/arc-visual-properties-devel.h>
30 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
31 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
32 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
33 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
34 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
35 #include <dali/devel-api/actors/actor-devel.h>
36 #include <dali/devel-api/object/handle-devel.h>
37 #include <dali/devel-api/text-abstraction/font-client.h>
38 #include <toolkit-event-thread-callback.h>
40 #include "dummy-control.h"
43 using namespace Dali::Toolkit;
47 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
48 const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
49 const char* TEST_NPATCH_FILE_NAME = TEST_RESOURCE_DIR "/button-up.9.png";
50 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
51 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
52 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
53 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
54 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
56 const std::string DEFAULT_FONT_DIR("/resources/fonts");
58 Property::Map DefaultTransform()
60 Property::Map transformMap;
62 .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
63 .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
64 .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
65 .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
66 .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
67 .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
71 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
73 if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
75 for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
77 const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
79 Property::Value* valueSet = NULL;
80 if(valueGet.first.type == Property::Key::INDEX)
82 valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
86 // Get Key is a string so searching Set Map for a string key
87 valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
92 if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
94 tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
97 else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
99 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
102 else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
104 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
107 else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
109 tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
112 else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
114 Vector2 vector2Get = valueGet.second.Get<Vector2>();
115 Vector2 vector2Set = valueSet->Get<Vector2>();
116 tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
119 else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
121 Vector4 vector4Get = valueGet.second.Get<Vector4>();
122 Vector4 vector4Set = valueSet->Get<Vector4>();
123 tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
129 if(valueGet.first.type == Property::Key::INDEX)
131 tet_printf(" The key %d doesn't exist.", valueGet.first.indexKey);
135 tet_printf(" The key %s doesn't exist.", valueGet.first.stringKey.c_str());
144 void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, bool>> substringCheckList, const char* location)
146 Renderer renderer = control.GetRendererAt(0);
147 Shader shader = renderer.GetShader();
148 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
149 Property::Map* map = value.GetMap();
150 DALI_TEST_CHECK(map);
152 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
153 std::string vertexShader;
154 DALI_TEST_CHECK(vertex->Get(vertexShader));
155 for(const auto& checkPair : substringCheckList)
157 const auto& keyword = checkPair.first;
158 const auto& expect = checkPair.second;
159 tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
160 DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
163 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
164 DALI_TEST_CHECK(fragment);
165 std::string fragmentShader;
166 DALI_TEST_CHECK(fragment->Get(fragmentShader));
167 for(const auto& checkPair : substringCheckList)
169 const auto& keyword = checkPair.first;
170 const auto& expect = checkPair.second;
171 tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
172 DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
176 void TestShaderCodeContainSubstringsForEachShader(Control control, std::vector<std::pair<std::string, std::pair<bool, bool>>> substringCheckList, const char* location)
178 Renderer renderer = control.GetRendererAt(0);
179 Shader shader = renderer.GetShader();
180 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
181 Property::Map* map = value.GetMap();
182 DALI_TEST_CHECK(map);
184 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
185 std::string vertexShader;
186 DALI_TEST_CHECK(vertex->Get(vertexShader));
187 for(const auto& checkPair : substringCheckList)
189 const auto& keyword = checkPair.first;
190 const auto& expect = checkPair.second.first;
191 tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
192 DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
195 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
196 DALI_TEST_CHECK(fragment);
197 std::string fragmentShader;
198 DALI_TEST_CHECK(fragment->Get(fragmentShader));
199 for(const auto& checkPair : substringCheckList)
201 const auto& keyword = checkPair.first;
202 const auto& expect = checkPair.second.second;
203 tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
204 DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
210 void dali_visual_startup(void)
212 test_return_value = TET_UNDEF;
215 void dali_visual_cleanup(void)
217 test_return_value = TET_PASS;
220 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
223 visual.CreatePropertyMap(map);
224 Property::Value* value = map.Find(mixColorIndex);
225 DALI_TEST_CHECK(value);
227 DALI_TEST_CHECK(value->Get(mixColor1));
228 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
230 value = map.Find(Visual::Property::MIX_COLOR);
231 DALI_TEST_CHECK(value);
233 DALI_TEST_CHECK(value->Get(mixColor2));
234 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
236 value = map.Find(Visual::Property::OPACITY);
237 DALI_TEST_CHECK(value);
239 DALI_TEST_CHECK(value->Get(opacity));
240 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
243 int UtcDaliVisualCopyAndAssignment(void)
245 ToolkitTestApplication application;
246 tet_infoline("UtcDaliVisualCopyAndAssignment");
248 VisualFactory factory = VisualFactory::Get();
249 Property::Map propertyMap;
250 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
251 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
252 Visual::Base visual = factory.CreateVisual(propertyMap);
254 Visual::Base visualCopy(visual);
255 DALI_TEST_CHECK(visual == visualCopy);
257 Visual::Base emptyVisual;
258 Visual::Base emptyVisualCopy(emptyVisual);
259 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
261 Visual::Base visualEquals;
262 visualEquals = visual;
263 DALI_TEST_CHECK(visual == visualEquals);
265 Visual::Base emptyVisualEquals;
266 emptyVisualEquals = emptyVisual;
267 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
271 DALI_TEST_CHECK(visual = visualCopy);
276 int UtcDaliVisualSetName01(void)
278 ToolkitTestApplication application;
279 tet_infoline("UtcDaliVisualSetName");
281 VisualFactory factory = VisualFactory::Get();
282 Property::Map propertyMap;
283 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
284 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
285 Visual::Base visual = factory.CreateVisual(propertyMap);
287 const char* visualName = "backgroundVisual";
288 visual.SetName(visualName);
290 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
295 int UtcDaliVisualSetGetDepthIndex(void)
297 ToolkitTestApplication application;
298 tet_infoline("UtcDaliVisualSetDepthIndex");
300 VisualFactory factory = VisualFactory::Get();
301 Property::Map propertyMap;
302 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
303 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
304 Visual::Base visual = factory.CreateVisual(propertyMap);
306 visual.SetDepthIndex(1);
308 DummyControl dummyControl = DummyControl::New(true);
309 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
310 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
312 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
313 application.GetScene().Add(dummyControl);
315 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
316 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
317 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
319 visual.SetDepthIndex(-1);
320 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
321 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
322 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
327 int UtcDaliVisualSize(void)
329 ToolkitTestApplication application;
330 tet_infoline("UtcDaliVisualSize");
332 VisualFactory factory = VisualFactory::Get();
333 Vector2 controlSize(20.f, 30.f);
337 Dali::Property::Map map;
338 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
339 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
341 Visual::Base colorVisual = factory.CreateVisual(map);
342 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
344 colorVisual.GetNaturalSize(naturalSize);
345 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
349 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
350 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
351 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
352 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
353 Visual::Base imageVisual = factory.CreateVisual(map);
354 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
356 imageVisual.GetNaturalSize(naturalSize);
357 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
359 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
362 float borderSize = 5.f;
364 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
365 map[BorderVisual::Property::COLOR] = Color::RED;
366 map[BorderVisual::Property::SIZE] = borderSize;
367 Visual::Base borderVisual = factory.CreateVisual(map);
368 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
369 borderVisual.GetNaturalSize(naturalSize);
370 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
372 // gradient gradientVisual
373 Property::Map propertyMap;
374 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
375 Vector2 start(-1.f, -1.f);
376 Vector2 end(1.f, 1.f);
377 propertyMap.Insert("mixColor", Color::MAGENTA);
378 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
379 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
380 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
381 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
382 Property::Array stopColors;
383 stopColors.PushBack(Color::RED);
384 stopColors.PushBack(Color::GREEN);
385 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
386 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
387 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
388 gradientVisual.GetNaturalSize(naturalSize);
389 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
391 // animated gradient visual
393 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
394 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
395 animatedGradientVisual.GetNaturalSize(naturalSize);
396 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
397 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
401 // Load some fonts to get the same metrics on different platforms.
402 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
403 fontClient.SetDpi(96u, 96u);
405 char* pathNamePtr = get_current_dir_name();
406 const std::string pathName(pathNamePtr);
409 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
411 // Create a TextVisual with a font size of 12 first
413 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
414 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
415 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
416 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
418 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
419 Vector2 smallTextVisualNaturalSize;
420 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
422 // Then create a TextVisual with a font size of 20
423 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
424 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
425 Vector2 largeTextVisualNaturalSize;
426 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
428 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
429 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
430 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
432 // The height returned for a particular width should also be greater for the large text visual
433 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
435 //AnimatedImageVisual
436 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
437 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
438 animatedImageVisual.GetNaturalSize(naturalSize);
439 // TEST_GIF_FILE: anim.gif
440 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
441 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
446 int UtcDaliVisualSetOnOffScene(void)
448 ToolkitTestApplication application;
449 tet_infoline("UtcDaliVisualSetOnOffScene");
451 VisualFactory factory = VisualFactory::Get();
452 Property::Map propertyMap;
453 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
454 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
455 Visual::Base visual = factory.CreateVisual(propertyMap);
457 DummyControl actor = DummyControl::New(true);
458 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
459 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
461 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
463 application.SendNotification();
464 application.Render(0);
465 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
467 application.GetScene().Add(actor);
469 application.SendNotification();
470 application.Render(0);
471 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
473 application.GetScene().Remove(actor);
475 application.SendNotification();
476 application.Render(0);
477 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
482 int UtcDaliVisualSetOnOffScene2(void)
484 ToolkitTestApplication application;
485 tet_infoline("UtcDaliVisualSetOnOffScene2");
487 VisualFactory factory = VisualFactory::Get();
488 Property::Map propertyMap;
489 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
490 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
491 Visual::Base visual = factory.CreateVisual(propertyMap);
493 DummyControl actor = DummyControl::New(true);
494 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
495 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
497 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
499 application.SendNotification();
500 application.Render(0);
501 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
504 application.GetScene().Add(actor);
506 application.SendNotification();
507 application.Render(0);
509 // Wait for loading & rasterization
510 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
512 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
513 Renderer renderer = actor.GetRendererAt(0);
514 auto textures = renderer.GetTextures();
515 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
517 application.GetScene().Remove(actor);
519 application.SendNotification();
520 application.Render(0);
521 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
524 application.GetScene().Add(actor);
526 application.SendNotification();
527 application.Render(0);
528 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
529 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
530 renderer = actor.GetRendererAt(0);
531 textures = renderer.GetTextures();
532 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
534 application.GetScene().Remove(actor);
536 application.SendNotification();
537 application.Render(0);
538 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
543 int UtcDaliVisualGetPropertyMap1(void)
545 ToolkitTestApplication application;
546 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
548 VisualFactory factory = VisualFactory::Get();
549 Property::Map propertyMap;
550 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
551 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
552 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
553 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
554 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
555 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
556 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
557 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
558 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
560 Property::Map resultMap;
561 colorVisual.CreatePropertyMap(resultMap);
563 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
564 DALI_TEST_CHECK(typeValue);
565 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
567 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
568 DALI_TEST_CHECK(colorValue);
569 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
571 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
572 DALI_TEST_CHECK(cornerRadiusValue);
573 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
575 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
576 DALI_TEST_CHECK(cornerRadiusPolicyValue);
577 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
579 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
580 DALI_TEST_CHECK(borderlineWidthValue);
581 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
583 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
584 DALI_TEST_CHECK(borderlineColorValue);
585 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
587 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
588 DALI_TEST_CHECK(borderlineOffsetValue);
589 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
591 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
592 DALI_TEST_CHECK(blurRadiusValue);
593 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
595 // change the blend color
596 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
597 colorVisual = factory.CreateVisual(propertyMap);
598 colorVisual.CreatePropertyMap(resultMap);
600 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
601 DALI_TEST_CHECK(colorValue);
602 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
605 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
607 colorVisual = factory.CreateVisual(propertyMap);
608 colorVisual.CreatePropertyMap(resultMap);
610 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
611 DALI_TEST_CHECK(blurRadiusValue);
612 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
617 int UtcDaliVisualGetPropertyMap2(void)
619 ToolkitTestApplication application;
620 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
622 VisualFactory factory = VisualFactory::Get();
623 Property::Map propertyMap;
624 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
625 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
626 propertyMap.Insert("borderColor", Color::BLUE);
627 propertyMap.Insert("borderSize", 5.f);
628 propertyMap.Insert("antiAliasing", true);
629 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
631 Property::Map resultMap;
632 borderVisual.CreatePropertyMap(resultMap);
634 // check the property values from the returned map from visual
635 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
636 DALI_TEST_CHECK(typeValue);
637 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
639 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
640 DALI_TEST_CHECK(colorValue);
641 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
643 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
644 DALI_TEST_CHECK(sizeValue);
645 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
647 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
648 DALI_TEST_CHECK(AAValue);
649 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
651 Property::Map propertyMap1;
652 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
653 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
654 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
655 borderVisual = factory.CreateVisual(propertyMap1);
656 borderVisual.CreatePropertyMap(resultMap);
658 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
659 DALI_TEST_CHECK(typeValue);
660 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
662 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
663 DALI_TEST_CHECK(colorValue);
664 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
666 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
667 DALI_TEST_CHECK(sizeValue);
668 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
673 int UtcDaliVisualGetPropertyMap2N(void)
675 ToolkitTestApplication application;
676 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
678 VisualFactory factory = VisualFactory::Get();
679 Property::Map propertyMap;
680 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
681 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
683 tet_infoline("Test that the visual is created, with a default renderer");
684 DALI_TEST_CHECK(borderVisual);
686 DummyControl dummyControl = DummyControl::New(true);
687 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
688 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
689 application.GetScene().Add(dummyControl);
691 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
696 int UtcDaliVisualGetPropertyMap3(void)
698 ToolkitTestApplication application;
699 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
701 VisualFactory factory = VisualFactory::Get();
702 DALI_TEST_CHECK(factory);
704 Property::Map propertyMap;
705 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
707 Vector2 start(-1.f, -1.f);
708 Vector2 end(1.f, 1.f);
709 propertyMap.Insert("startPosition", start);
710 propertyMap.Insert("endPosition", end);
711 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
713 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
715 Property::Array stopColors;
716 stopColors.PushBack(Color::RED);
717 stopColors.PushBack(Color::GREEN);
718 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
720 float borderlineWidth = 4.0f;
721 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
722 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
723 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
725 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
727 Property::Map resultMap;
728 gradientVisual.CreatePropertyMap(resultMap);
730 // check the property values from the returned map from visual
731 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
732 DALI_TEST_CHECK(value);
733 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
735 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
736 DALI_TEST_CHECK(value);
737 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
739 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
740 DALI_TEST_CHECK(value);
741 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
743 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
744 DALI_TEST_CHECK(value);
745 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
747 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
748 DALI_TEST_CHECK(value);
749 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
751 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
752 DALI_TEST_CHECK(value);
753 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
755 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
756 DALI_TEST_CHECK(value);
757 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
759 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
760 DALI_TEST_CHECK(value);
761 Property::Array* offsetArray = value->GetArray();
762 DALI_TEST_CHECK(offsetArray->Count() == 2);
763 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
764 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
766 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
767 DALI_TEST_CHECK(value);
768 Property::Array* colorArray = value->GetArray();
769 DALI_TEST_CHECK(colorArray->Count() == 2);
770 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
771 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
776 int UtcDaliVisualGetPropertyMap4(void)
778 ToolkitTestApplication application;
779 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
781 VisualFactory factory = VisualFactory::Get();
782 DALI_TEST_CHECK(factory);
784 Property::Map propertyMap;
785 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
787 Vector2 center(100.f, 100.f);
788 float radius = 100.f;
789 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
790 propertyMap.Insert(GradientVisual::Property::CENTER, center);
791 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
792 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
794 Property::Array stopColors;
795 stopColors.PushBack(Color::RED);
796 stopColors.PushBack(Color::BLACK);
797 stopColors.PushBack(Color::GREEN);
798 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
800 float borderlineWidth = 8.0f;
801 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
802 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
803 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
805 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
806 DALI_TEST_CHECK(gradientVisual);
808 Property::Map resultMap;
809 gradientVisual.CreatePropertyMap(resultMap);
811 // check the property values from the returned map from visual
812 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
813 DALI_TEST_CHECK(value);
814 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
816 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
817 DALI_TEST_CHECK(value);
818 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
820 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
821 DALI_TEST_CHECK(value);
822 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
824 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
825 DALI_TEST_CHECK(value);
826 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
828 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
829 DALI_TEST_CHECK(value);
830 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
832 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
833 DALI_TEST_CHECK(value);
834 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
836 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
837 DALI_TEST_CHECK(value);
838 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
840 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
841 DALI_TEST_CHECK(value);
842 Property::Array* offsetArray = value->GetArray();
843 DALI_TEST_CHECK(offsetArray->Count() == 3);
844 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
845 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
846 // any stop value will be clamped to [0.0, 1.0];
847 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
849 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
850 DALI_TEST_CHECK(value);
851 Property::Array* colorArray = value->GetArray();
852 DALI_TEST_CHECK(colorArray->Count() == 3);
853 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
854 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
855 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
860 int UtcDaliVisualGetPropertyMap5(void)
862 ToolkitTestApplication application;
863 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
865 VisualFactory factory = VisualFactory::Get();
866 Property::Map propertyMap;
867 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
868 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
869 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
870 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
871 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
872 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
873 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
874 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
875 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
876 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
877 propertyMap.Insert("synchronousLoading", true);
879 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
880 DALI_TEST_CHECK(imageVisual);
882 Property::Map resultMap;
883 imageVisual.CreatePropertyMap(resultMap);
885 // check the property values from the returned map from visual
886 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
887 DALI_TEST_CHECK(value);
888 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
890 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
891 DALI_TEST_CHECK(value);
892 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
894 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
895 DALI_TEST_CHECK(value);
896 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
898 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
899 DALI_TEST_CHECK(value);
900 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
902 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
903 DALI_TEST_CHECK(value);
904 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
906 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
907 DALI_TEST_CHECK(value);
908 DALI_TEST_CHECK(value->Get<int>() == 20);
910 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
911 DALI_TEST_CHECK(value);
912 DALI_TEST_CHECK(value->Get<int>() == 30);
914 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
915 DALI_TEST_CHECK(value);
916 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
918 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
919 DALI_TEST_CHECK(value);
920 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
922 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
923 DALI_TEST_CHECK(value);
924 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
926 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
927 DALI_TEST_CHECK(value);
928 DALI_TEST_CHECK(value->Get<bool>() == true);
933 int UtcDaliVisualGetPropertyMap6(void)
935 ToolkitTestApplication application;
936 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
938 Rect<int> border(1, 1, 1, 1);
940 VisualFactory factory = VisualFactory::Get();
941 Property::Map propertyMap;
942 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
943 propertyMap.Insert("mixColor", Color::MAGENTA);
944 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
945 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
946 propertyMap.Insert(ImageVisual::Property::BORDER, border);
947 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
948 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
949 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
951 Property::Map resultMap;
952 nPatchVisual.CreatePropertyMap(resultMap);
954 // check the property values from the returned map from visual
955 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
956 DALI_TEST_CHECK(value);
957 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
959 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
960 DALI_TEST_CHECK(value);
961 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
963 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
964 DALI_TEST_CHECK(value);
965 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
967 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
968 DALI_TEST_CHECK(value);
969 DALI_TEST_CHECK(value->Get<bool>());
971 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
972 DALI_TEST_CHECK(value);
973 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
975 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
976 DALI_TEST_CHECK(value);
977 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
979 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
980 DALI_TEST_CHECK(value);
981 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
983 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
985 Property::Map propertyMap1;
986 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
987 propertyMap1.Insert("mixColor", Color::MAGENTA);
988 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
989 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
990 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
991 nPatchVisual = factory.CreateVisual(propertyMap1);
993 nPatchVisual.CreatePropertyMap(resultMap);
995 // check the property values from the returned map from visual
996 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
997 DALI_TEST_CHECK(value);
998 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
1000 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1001 DALI_TEST_CHECK(value);
1002 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
1004 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1005 DALI_TEST_CHECK(value);
1006 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
1008 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
1009 DALI_TEST_CHECK(value);
1010 DALI_TEST_CHECK(value->Get<bool>());
1012 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
1013 DALI_TEST_CHECK(value);
1014 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
1019 int UtcDaliVisualGetPropertyMap7(void)
1021 ToolkitTestApplication application;
1022 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
1024 // request SvgVisual with a property map
1025 VisualFactory factory = VisualFactory::Get();
1026 Property::Map propertyMap;
1027 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
1028 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
1029 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
1030 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
1031 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
1033 Property::Map resultMap;
1034 svgVisual.CreatePropertyMap(resultMap);
1035 // check the property values from the returned map from a visual
1036 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1037 DALI_TEST_CHECK(value);
1038 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1040 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1041 DALI_TEST_CHECK(value);
1042 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1044 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1045 DALI_TEST_CHECK(value);
1046 DALI_TEST_CHECK(value->Get<bool>() == false);
1048 // request SvgVisual with a property map 2
1049 propertyMap.Clear();
1050 propertyMap["visualType"] = Visual::SVG;
1051 propertyMap["mixColor"] = Color::WHITE;
1052 propertyMap["url"] = TEST_SVG_FILE_NAME;
1053 propertyMap["atlasing"] = true;
1054 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1057 svgVisual1.CreatePropertyMap(resultMap);
1058 // check the property values from the returned map from a visual
1059 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1060 DALI_TEST_CHECK(value);
1061 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1063 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1064 DALI_TEST_CHECK(value);
1065 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1067 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1068 DALI_TEST_CHECK(value);
1069 DALI_TEST_CHECK(value->Get<bool>() == true);
1071 // request SvgVisual with an URL
1072 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1074 svgVisual2.CreatePropertyMap(resultMap);
1075 // check the property values from the returned map from a visual
1076 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1077 DALI_TEST_CHECK(value);
1078 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1080 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1081 DALI_TEST_CHECK(value);
1082 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1088 int UtcDaliVisualGetPropertyMap8(void)
1090 ToolkitTestApplication application;
1091 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1093 //Request MeshVisual using a property map.
1094 VisualFactory factory = VisualFactory::Get();
1095 Property::Map propertyMap;
1096 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1097 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1098 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1099 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1100 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1101 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1102 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1103 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1105 Property::Map resultMap;
1106 meshVisual.CreatePropertyMap(resultMap);
1107 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1109 //Check values in the result map are identical to the initial map's values.
1110 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1111 DALI_TEST_CHECK(value);
1112 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1114 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1115 DALI_TEST_CHECK(value);
1116 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1118 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1119 DALI_TEST_CHECK(value);
1120 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1122 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1123 DALI_TEST_CHECK(value);
1124 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1126 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1127 DALI_TEST_CHECK(value);
1128 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1130 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1131 DALI_TEST_CHECK(value);
1132 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1137 //Primitive shape visual
1138 int UtcDaliVisualGetPropertyMap9(void)
1140 ToolkitTestApplication application;
1141 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1143 static std::vector<UniformData> customUniforms =
1145 UniformData("mixColor", Property::Type::VECTOR3),
1148 TestGraphicsController& graphics = application.GetGraphicsController();
1149 graphics.AddCustomUniforms(customUniforms);
1151 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1152 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1154 //Request PrimitiveVisual using a property map.
1155 VisualFactory factory = VisualFactory::Get();
1156 Property::Map propertyMap;
1157 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1158 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1159 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1160 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1161 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1162 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1163 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1164 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1165 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1166 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1167 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1168 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1169 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1170 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1172 Property::Map resultMap;
1173 primitiveVisual.CreatePropertyMap(resultMap);
1175 //Check values in the result map are identical to the initial map's values.
1176 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1177 DALI_TEST_CHECK(value);
1178 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1180 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1181 DALI_TEST_CHECK(value);
1182 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1184 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1185 DALI_TEST_CHECK(value);
1186 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1187 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1189 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1190 DALI_TEST_CHECK(value);
1191 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1193 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1194 DALI_TEST_CHECK(value);
1195 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1197 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1198 DALI_TEST_CHECK(value);
1199 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1201 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1202 DALI_TEST_CHECK(value);
1203 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1205 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1206 DALI_TEST_CHECK(value);
1207 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1209 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1210 DALI_TEST_CHECK(value);
1211 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1213 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1214 DALI_TEST_CHECK(value);
1215 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1217 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1218 DALI_TEST_CHECK(value);
1219 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1221 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1222 DALI_TEST_CHECK(value);
1223 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1225 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1226 DALI_TEST_CHECK(value);
1227 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1229 DummyControl actor = DummyControl::New(true);
1230 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1231 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1232 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1233 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1234 application.GetScene().Add(actor);
1236 Animation animation = Animation::New(1.0f);
1237 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1239 application.SendNotification();
1240 application.Render(0);
1241 application.Render(1000);
1242 application.SendNotification();
1244 auto& gl = application.GetGlAbstraction();
1245 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1247 tet_infoline("Check property map after animation");
1249 primitiveVisual.CreatePropertyMap(resultMap);
1250 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1251 DALI_TEST_CHECK(value);
1252 color = value->Get<Vector4>();
1253 // Ignore alpha part
1254 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1260 int UtcDaliVisualGetPropertyMap10(void)
1262 ToolkitTestApplication application;
1263 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1265 //Request PrimitiveVisual using a property map.
1266 VisualFactory factory = VisualFactory::Get();
1268 Property::Map propertyMap;
1269 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1270 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1271 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1272 propertyMap.Insert("enableMarkup", false);
1273 propertyMap.Insert("text", "Hello world");
1274 propertyMap.Insert("fontFamily", "TizenSans");
1276 Property::Map fontStyleMapSet;
1277 fontStyleMapSet.Insert("weight", "bold");
1278 propertyMap.Insert("fontStyle", fontStyleMapSet);
1280 propertyMap.Insert("pointSize", 12.f);
1281 propertyMap.Insert("multiLine", true);
1282 propertyMap.Insert("horizontalAlignment", "CENTER");
1283 propertyMap.Insert("verticalAlignment", "CENTER");
1284 propertyMap.Insert("textColor", Color::RED);
1286 Property::Map shadowMapSet;
1287 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1289 Property::Map underlineMapSet;
1290 propertyMap.Insert("underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1).Add("type", Text::Underline::Type::SOLID).Add("dashWidth", 2).Add("dashGap", 1));
1292 Property::Map outlineMapSet;
1293 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1295 Property::Map backgroundMapSet;
1296 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1298 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1300 Property::Map resultMap;
1301 textVisual.CreatePropertyMap(resultMap);
1303 //Check values in the result map are identical to the initial map's values.
1304 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1305 DALI_TEST_CHECK(value);
1306 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1308 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1309 DALI_TEST_CHECK(value);
1310 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1312 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1313 DALI_TEST_CHECK(value);
1314 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1316 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1317 DALI_TEST_CHECK(value);
1318 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1320 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1321 DALI_TEST_CHECK(value);
1323 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1324 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1325 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1327 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1328 DALI_TEST_CHECK(value);
1329 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1331 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1332 DALI_TEST_CHECK(value);
1333 DALI_TEST_CHECK(value->Get<bool>());
1335 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1336 DALI_TEST_CHECK(value);
1337 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1339 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1340 DALI_TEST_CHECK(value);
1341 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1343 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1344 DALI_TEST_CHECK(value);
1345 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1347 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1348 DALI_TEST_CHECK(value);
1349 DALI_TEST_CHECK(!value->Get<bool>());
1351 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1352 DALI_TEST_CHECK(value);
1354 Property::Map shadowMapGet = value->Get<Property::Map>();
1355 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1356 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1358 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1359 DALI_TEST_CHECK(value);
1361 Property::Map underlineMapGet = value->Get<Property::Map>();
1362 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1363 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1365 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1366 DALI_TEST_CHECK(value);
1368 Property::Map outlineMapGet = value->Get<Property::Map>();
1369 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1370 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1372 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1373 DALI_TEST_CHECK(value);
1375 Property::Map backgroundMapGet = value->Get<Property::Map>();
1376 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1377 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1382 int UtcDaliVisualGetPropertyMap11(void)
1384 ToolkitTestApplication application;
1385 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1387 VisualFactory factory = VisualFactory::Get();
1388 DALI_TEST_CHECK(factory);
1390 Property::Map propertyMap;
1391 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1393 Vector2 start(-0.5f, 0.5f);
1394 Vector2 end(0.5f, -0.0f);
1395 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1396 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1397 Vector2 rotate_center(0.0f, 0.4f);
1398 float rotate_amount = 1.57f;
1399 float offset = 100.f;
1401 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1402 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1403 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1405 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1406 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1407 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1408 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1409 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1410 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1411 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1413 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1414 DALI_TEST_CHECK(animatedGradientVisual);
1416 Property::Map resultMap;
1417 animatedGradientVisual.CreatePropertyMap(resultMap);
1419 // check the property values from the returned map from visual
1420 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1421 DALI_TEST_CHECK(value);
1422 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1424 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1425 DALI_TEST_CHECK(value);
1426 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1428 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1429 DALI_TEST_CHECK(value);
1430 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1432 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1433 DALI_TEST_CHECK(value);
1434 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1436 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1437 DALI_TEST_CHECK(value);
1438 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1440 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1441 DALI_TEST_CHECK(value);
1442 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1444 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1445 DALI_TEST_CHECK(value);
1446 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1448 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1449 DALI_TEST_CHECK(value);
1450 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1452 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1453 DALI_TEST_CHECK(value);
1454 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1456 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1457 DALI_TEST_CHECK(value);
1458 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1460 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1461 DALI_TEST_CHECK(value);
1462 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1467 int UtcDaliVisualGetPropertyMap12(void)
1469 ToolkitTestApplication application;
1470 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1472 // Case 1 : Set values by index
1474 tet_printf(" - Set Values by Index\n");
1475 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1476 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1477 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1479 tet_printf("test with delay [%f]\n", _delay);
1480 VisualFactory factory = VisualFactory::Get();
1481 DALI_TEST_CHECK(factory);
1483 Property::Map propertyMap;
1484 Property::Map animationMap;
1485 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1487 float duration = 1.1f;
1488 float delay = _delay;
1489 float repeat_delay = 0.4f;
1491 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1493 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1494 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1496 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1497 animationMap.Clear();
1498 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1499 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1500 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1501 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1502 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1503 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1504 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1505 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1506 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1508 return animationMap;
1511 Vector2 start1(-0.5f, 0.5f);
1512 Vector2 end1(0.5f, -0.5f);
1513 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1514 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1515 Vector2 rotate_center1(0.0f, 0.4f);
1516 float rotate_amount1 = 0.0f;
1517 float offset1 = 0.f;
1519 Vector2 start2(-0.5f, -0.5f);
1520 Vector2 end2(0.5f, 0.5f);
1521 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1522 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1523 Vector2 rotate_center2(0.0f, -0.4f);
1524 float rotate_amount2 = 6.2832f;
1525 float offset2 = 2.f;
1527 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1528 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1529 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1531 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1532 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1533 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1534 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1535 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1536 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1537 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1539 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1540 DALI_TEST_CHECK(animatedGradientVisual);
1542 Property::Map resultMap;
1543 animatedGradientVisual.CreatePropertyMap(resultMap);
1545 // check the property values from the returned map from visual
1546 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1547 DALI_TEST_CHECK(value);
1548 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1550 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1551 DALI_TEST_CHECK(value);
1552 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1554 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1555 DALI_TEST_CHECK(value);
1556 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1558 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1559 DALI_TEST_CHECK(value);
1560 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1562 auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1563 tet_printf("Check value at %d\n", line_num);
1564 value = resultMap.Find(index, Property::MAP);
1565 DALI_TEST_CHECK(value);
1566 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1567 Property::Map* temp_map = value->GetMap();
1568 DALI_TEST_CHECK(temp_map);
1570 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1571 Property::Value* res = temp_map->Find(index);
1572 DALI_TEST_CHECK(res);
1576 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1577 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1578 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1579 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1580 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1581 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1582 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1583 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1584 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1587 // check the animation map data is good
1588 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1589 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1590 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1591 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1592 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1593 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1594 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1598 // Case 2 : Set values by string
1600 tet_printf(" - Set Values by String\n");
1601 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1602 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1603 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1605 tet_printf("test with delay [%f]\n", _delay);
1606 VisualFactory factory = VisualFactory::Get();
1607 DALI_TEST_CHECK(factory);
1609 Property::Map propertyMap;
1610 Property::Map animationMap;
1611 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1613 float duration = 1.1f;
1614 float delay = _delay;
1615 float repeat_delay = 0.4f;
1617 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1619 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1620 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1622 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1623 animationMap.Clear();
1624 animationMap.Insert("startValue", start);
1625 animationMap.Insert("targetValue", target);
1626 animationMap.Insert("directionType", "BACKWARD");
1627 animationMap.Insert("duration", duration);
1628 animationMap.Insert("delay", delay);
1629 animationMap.Insert("repeat", loop_count);
1630 animationMap.Insert("repeatDelay", repeat_delay);
1631 animationMap.Insert("motionType", "MIRROR");
1632 animationMap.Insert("easingType", "IN_OUT");
1634 return animationMap;
1637 Vector2 start1(-0.5f, 0.5f);
1638 Vector2 end1(0.5f, -0.5f);
1639 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1640 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1641 Vector2 rotate_center1(0.0f, 0.4f);
1642 float rotate_amount1 = 0.0f;
1643 float offset1 = 0.f;
1645 Vector2 start2(-0.5f, -0.5f);
1646 Vector2 end2(0.5f, 0.5f);
1647 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1648 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1649 Vector2 rotate_center2(0.0f, -0.4f);
1650 float rotate_amount2 = 6.2832f;
1651 float offset2 = 2.f;
1653 // For test mix the type string/index key and string/index value works well.
1654 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1655 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1656 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1658 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1659 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1660 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1661 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1662 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1663 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1664 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1666 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1667 DALI_TEST_CHECK(animatedGradientVisual);
1669 Property::Map resultMap;
1670 animatedGradientVisual.CreatePropertyMap(resultMap);
1672 // check the property values from the returned map from visual
1673 // Note : resultMap from CreatePropertyMap only contain indexKey
1674 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1675 DALI_TEST_CHECK(value);
1676 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1678 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1679 DALI_TEST_CHECK(value);
1680 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1682 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1683 DALI_TEST_CHECK(value);
1684 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1686 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1687 DALI_TEST_CHECK(value);
1688 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1690 auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1691 tet_printf("Check value at %d\n", line_num);
1692 value = resultMap.Find(index, Property::MAP);
1693 DALI_TEST_CHECK(value);
1694 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1695 Property::Map* temp_map = value->GetMap();
1696 DALI_TEST_CHECK(temp_map);
1698 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1699 Property::Value* res = temp_map->Find(index);
1700 DALI_TEST_CHECK(res);
1704 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1705 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1706 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1707 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1708 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1709 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1710 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1711 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1712 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1715 // check the animation map data is good
1716 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1717 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1718 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1719 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1720 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1721 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1722 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1728 int UtcDaliVisualGetPropertyMap13(void)
1730 ToolkitTestApplication application;
1731 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1733 for(int _direction = 0; _direction <= 1; ++_direction)
1735 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1737 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1738 VisualFactory factory = VisualFactory::Get();
1739 DALI_TEST_CHECK(factory);
1741 Property::Map propertyMap;
1742 Property::Map animationMap;
1743 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1745 float duration = 1.0f;
1746 float delay = _delay;
1747 float repeat_delay = 0.5f;
1749 int direction = _direction;
1750 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1751 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1752 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1754 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1755 animationMap.Clear();
1756 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1757 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1759 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1761 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1762 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1763 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1764 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1765 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1766 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1767 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1768 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1770 return animationMap;
1773 Vector2 start1(-0.5f, 0.5f);
1774 Vector2 end1(0.5f, -0.5f);
1775 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1776 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1777 Vector2 rotate_center1(1.0f, 0.4f);
1778 float rotate_amount1 = 2.0f;
1779 float offset1 = 1.f;
1781 Vector2 start2(-0.5f, -0.5f);
1782 Vector2 end2(0.5f, 0.5f);
1783 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1784 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1785 Vector2 rotate_center2(1.0f, -0.4f);
1786 float rotate_amount2 = 1.0f;
1787 float offset2 = 3.f;
1789 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1790 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1791 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1793 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1794 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1795 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1796 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1797 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1798 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1799 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1801 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1802 DALI_TEST_CHECK(animatedGradientVisual);
1804 Property::Map resultMap;
1805 animatedGradientVisual.CreatePropertyMap(resultMap);
1807 // check the property values from the returned map from visual
1808 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1809 DALI_TEST_CHECK(value);
1810 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1812 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1813 DALI_TEST_CHECK(value);
1814 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1816 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1817 DALI_TEST_CHECK(value);
1818 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1820 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1821 DALI_TEST_CHECK(value);
1822 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1824 // If loop_count = 0, Animation doesn't created.
1825 // Optimized resultMap only have one value, which is target value
1826 // Note: target value will be changed by direction option.
1827 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1828 DALI_TEST_CHECK(value);
1829 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1831 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1832 DALI_TEST_CHECK(value);
1833 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1835 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1836 DALI_TEST_CHECK(value);
1837 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1839 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1840 DALI_TEST_CHECK(value);
1841 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1843 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1844 DALI_TEST_CHECK(value);
1845 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1847 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1848 DALI_TEST_CHECK(value);
1849 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1851 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1852 DALI_TEST_CHECK(value);
1853 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1860 int UtcDaliVisualAnimateArcVisual(void)
1862 ToolkitTestApplication application;
1863 tet_infoline("UtcDaliVisualAnimateArcVisual color");
1865 static std::vector<UniformData> customUniforms =
1867 UniformData("startAngle", Property::Type::FLOAT),
1868 UniformData("sweepAngle", Property::Type::FLOAT),
1871 TestGraphicsController& graphics = application.GetGraphicsController();
1872 graphics.AddCustomUniforms(customUniforms);
1874 VisualFactory factory = VisualFactory::Get();
1875 Property::Map propertyMap;
1876 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ARC);
1877 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1878 propertyMap.Insert(DevelArcVisual::Property::START_ANGLE, 0.0f);
1879 propertyMap.Insert(DevelArcVisual::Property::SWEEP_ANGLE, 90.0f);
1880 propertyMap.Insert(DevelArcVisual::Property::CAP, DevelArcVisual::Cap::ROUND);
1881 propertyMap.Insert(DevelArcVisual::Property::THICKNESS, 20.0f);
1882 Visual::Base arcVisual = factory.CreateVisual(propertyMap);
1884 DummyControl actor = DummyControl::New(true);
1885 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1886 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, arcVisual);
1887 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1888 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1889 application.GetScene().Add(actor);
1891 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1893 Renderer renderer = actor.GetRendererAt(0);
1894 Property::Index index = renderer.GetPropertyIndex(DevelArcVisual::Property::SWEEP_ANGLE);
1896 Animation animation = Animation::New(4.0f);
1897 animation.AnimateTo(Property(renderer, index), 50.0f);
1898 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelArcVisual::Property::START_ANGLE), 40.0f);
1901 application.SendNotification();
1902 application.Render(0);
1903 application.Render(2000u); // halfway point
1905 float sweepAngle = renderer.GetCurrentProperty<float>(index);
1906 DALI_TEST_EQUALS(sweepAngle, 70.0f, 0.0001f, TEST_LOCATION);
1907 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 20.0f), true, TEST_LOCATION);
1908 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 70.0f), true, TEST_LOCATION);
1910 application.Render(2000u); // another halfway point
1912 sweepAngle = renderer.GetCurrentProperty<float>(index);
1913 DALI_TEST_EQUALS(sweepAngle, 50.0f, 0.0001f, TEST_LOCATION);
1914 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 40.0f), true, TEST_LOCATION);
1915 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 50.0f), true, TEST_LOCATION);
1920 int UtcDaliVisualAnimateBorderVisual01(void)
1922 ToolkitTestApplication application;
1923 tet_infoline("UtcDaliAnimateBorderVisual Color");
1925 static std::vector<UniformData> customUniforms =
1927 UniformData("borderColor", Property::Type::VECTOR4),
1928 UniformData("mixColor", Property::Type::VECTOR3),
1931 TestGraphicsController& graphics = application.GetGraphicsController();
1932 graphics.AddCustomUniforms(customUniforms);
1934 VisualFactory factory = VisualFactory::Get();
1935 Property::Map propertyMap;
1936 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1937 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1938 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1939 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1940 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1943 map["target"] = "testVisual";
1944 map["property"] = "mixColor";
1945 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1946 map["animator"] = Property::Map()
1947 .Add("alphaFunction", "LINEAR")
1948 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1950 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1952 DummyControl actor = DummyControl::New(true);
1953 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1954 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1955 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1956 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1957 application.GetScene().Add(actor);
1959 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1961 Renderer renderer = actor.GetRendererAt(0);
1962 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1963 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1965 Animation animation = dummyImpl.CreateTransition(transition);
1967 // Animate the mix color through the transition, and the border color through
1968 // programmatic method.
1969 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1972 application.SendNotification();
1973 application.Render(0);
1974 application.Render(2000u); // halfway point between blue and white
1976 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1977 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1978 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1979 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1981 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1982 testColor = Vector4(1, 1, 1, 0.45f);
1983 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1984 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1987 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1988 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1990 application.Render(2000u);
1992 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1993 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1994 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1996 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1997 testColor = Vector4(1, 1, 1, 0.1);
1998 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1999 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
2001 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
2002 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
2007 int UtcDaliVisualAnimateBorderVisual02(void)
2009 ToolkitTestApplication application;
2010 tet_infoline("UtcDaliAnimateBorderVisual Size");
2012 static std::vector<UniformData> customUniforms =
2014 UniformData("borderSize", Property::Type::FLOAT),
2017 TestGraphicsController& graphics = application.GetGraphicsController();
2018 graphics.AddCustomUniforms(customUniforms);
2020 VisualFactory factory = VisualFactory::Get();
2021 Property::Map propertyMap;
2022 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
2023 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
2024 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
2025 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
2027 DummyControl actor = DummyControl::New(true);
2028 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2029 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
2030 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2031 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2032 application.GetScene().Add(actor);
2034 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2036 Renderer renderer = actor.GetRendererAt(0);
2037 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
2039 Animation animation = Animation::New(4.0f);
2040 animation.AnimateTo(Property(renderer, index), 9.0f);
2043 application.SendNotification();
2044 application.Render(0);
2045 application.Render(2000u); // halfway point
2047 float size = renderer.GetCurrentProperty<float>(index);
2048 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
2049 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
2051 application.Render(2000u); // halfway point between blue and white
2053 size = renderer.GetCurrentProperty<float>(index);
2054 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
2055 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
2060 int UtcDaliVisualAnimateColorVisual(void)
2062 ToolkitTestApplication application;
2063 tet_infoline("UtcDaliAnimateColorVisual mixColor");
2065 static std::vector<UniformData> customUniforms =
2067 UniformData("mixColor", Property::Type::VECTOR3),
2070 TestGraphicsController& graphics = application.GetGraphicsController();
2071 graphics.AddCustomUniforms(customUniforms);
2073 VisualFactory factory = VisualFactory::Get();
2074 Property::Map propertyMap;
2075 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2076 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2077 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
2079 DummyControl actor = DummyControl::New(true);
2080 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2081 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
2082 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2083 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2084 application.GetScene().Add(actor);
2086 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2088 Renderer renderer = actor.GetRendererAt(0);
2089 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
2091 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
2092 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2094 Animation animation = Animation::New(4.0f);
2095 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2098 application.SendNotification();
2099 application.Render(0);
2100 application.Render(2000u); // halfway point
2102 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2103 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2104 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2106 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2108 application.Render(2000u); // halfway point between blue and white
2110 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2111 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2113 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2115 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2116 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2121 int UtcDaliVisualAnimatePrimitiveVisual(void)
2123 ToolkitTestApplication application;
2124 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2126 static std::vector<UniformData> customUniforms =
2128 UniformData("mixColor", Property::Type::VECTOR3),
2131 TestGraphicsController& graphics = application.GetGraphicsController();
2132 graphics.AddCustomUniforms(customUniforms);
2135 VisualFactory factory = VisualFactory::Get();
2136 Property::Map propertyMap;
2137 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2138 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2139 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2140 Visual::Base visual = factory.CreateVisual(propertyMap);
2142 DummyControl actor = DummyControl::New(true);
2143 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2144 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2145 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2146 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2147 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2148 application.GetScene().Add(actor);
2150 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2152 Renderer renderer = actor.GetRendererAt(0);
2154 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2155 const Vector4 TARGET_MIX_COLOR(Color::RED);
2158 map["target"] = "testVisual";
2159 map["property"] = "mixColor";
2160 map["initialValue"] = INITIAL_MIX_COLOR;
2161 map["targetValue"] = TARGET_MIX_COLOR;
2162 map["animator"] = Property::Map()
2163 .Add("alphaFunction", "LINEAR")
2164 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2166 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2168 Animation animation = dummyImpl.CreateTransition(transition);
2169 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2172 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2173 glAbstraction.EnableEnableDisableCallTrace(true);
2174 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2175 std::ostringstream blendStr;
2176 blendStr << std::hex << GL_BLEND;
2178 application.SendNotification();
2179 application.Render(0);
2180 application.Render(2000u); // halfway point
2181 application.SendNotification();
2183 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2184 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2185 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2187 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2189 glEnableStack.Reset();
2191 application.Render(2001u); // go past end
2192 application.SendNotification(); // Trigger signals
2194 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2195 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2196 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2198 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2206 int UtcDaliVisualAnimatedGradientVisual01(void)
2208 ToolkitTestApplication application;
2209 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2211 static std::vector<UniformData> customUniforms =
2213 UniformData("start_point", Property::Type::VECTOR2),
2214 UniformData("end_point", Property::Type::VECTOR2),
2215 UniformData("start_color", Property::Type::VECTOR4),
2216 UniformData("end_color", Property::Type::VECTOR4),
2217 UniformData("rotate_center", Property::Type::VECTOR2),
2218 UniformData("rotate_angle", Property::Type::FLOAT),
2219 UniformData("gradient_offset", Property::Type::FLOAT),
2222 TestGraphicsController& graphics = application.GetGraphicsController();
2223 graphics.AddCustomUniforms(customUniforms);
2226 VisualFactory factory = VisualFactory::Get();
2227 Property::Map propertyMap;
2228 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2229 Visual::Base visual = factory.CreateVisual(propertyMap);
2231 DummyControl actor = DummyControl::New(true);
2232 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2233 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2234 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2235 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2236 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2237 application.GetScene().Add(actor);
2239 application.SendNotification();
2240 application.Render(0);
2241 application.SendNotification();
2243 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2245 for(int step_iter = 0; step_iter < 3; step_iter++)
2247 application.SendNotification();
2248 application.Render(0);
2249 application.Render(750u); // step i/4
2250 application.SendNotification();
2252 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2253 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2254 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2255 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2256 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2257 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2258 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2261 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2262 application.Render(750u); // go to end
2263 application.SendNotification();
2265 application.Render(10u); // finish
2266 application.SendNotification();
2269 application.SendNotification();
2270 application.Render(0u);
2271 application.SendNotification();
2277 int UtcDaliVisualAnimatedGradientVisual02(void)
2279 ToolkitTestApplication application;
2280 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2282 static std::vector<UniformData> customUniforms =
2284 UniformData("start_point", Property::Type::VECTOR2),
2285 UniformData("end_point", Property::Type::VECTOR2),
2286 UniformData("start_color", Property::Type::VECTOR4),
2287 UniformData("end_color", Property::Type::VECTOR4),
2288 UniformData("rotate_center", Property::Type::VECTOR2),
2289 UniformData("rotate_angle", Property::Type::FLOAT),
2290 UniformData("gradient_offset", Property::Type::FLOAT),
2293 TestGraphicsController& graphics = application.GetGraphicsController();
2294 graphics.AddCustomUniforms(customUniforms);
2297 float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2298 int _direction[2] = {0, 1};
2299 int _loop_count[3] = {-1, 0, 1};
2300 int _motion[2] = {0, 1};
2301 int _easing[4] = {0, 1, 2, 3};
2303 int test_case_max = 4 * 2 * 3 * 2 * 4;
2305 int test_case_d = 7; // 7 is the number of animated properties.
2307 float _duration = 0.4f;
2308 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2309 float noise_maker = 0.0f;
2310 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2311 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2313 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2315 VisualFactory factory = VisualFactory::Get();
2316 Property::Map propertyMap;
2317 Property::Map animationMap;
2318 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2320 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2321 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2322 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2324 auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2325 int tc = (test_case + tc_offset);
2326 int idx_easing = tc % 4;
2328 int idx_motion = tc % 2;
2330 int idx_loop_count = tc % 3;
2332 int idx_direction = tc % 2;
2334 int idx_delay = tc % 4;
2337 float duration = _duration - _repeat_delay;
2338 float repeat_delay = _repeat_delay;
2339 float delay = _delay[idx_delay] * _duration;
2340 int direction = _direction[idx_direction];
2341 int loop_count = _loop_count[idx_loop_count];
2342 int motion = _motion[idx_motion];
2343 int easing = _easing[idx_easing];
2345 animationMap.Clear();
2346 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2347 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2350 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2354 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2356 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2357 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2358 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2359 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2362 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2366 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2370 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2372 else if(easing == 1)
2374 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2376 else if(easing == 2)
2378 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2382 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2385 return animationMap;
2388 // Give different values for debuging
2389 noise_maker += 1.0f;
2390 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2391 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2392 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2393 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2394 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2395 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2396 float offset1 = 0.f + noise_maker * 0.1f;
2398 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2399 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2400 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2401 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2402 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2403 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2404 float offset2 = 2.f + noise_maker * 0.1f;
2406 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2407 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2408 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2410 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2411 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2412 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2413 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2414 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2415 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2416 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2418 Visual::Base visual = factory.CreateVisual(propertyMap);
2420 DummyControl actor = DummyControl::New(true);
2421 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2422 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2423 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2424 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2425 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2426 application.GetScene().Add(actor);
2428 application.SendNotification();
2429 application.Render(0);
2430 application.SendNotification();
2432 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2434 application.SendNotification();
2436 //Compare between CPU calculated value and Shader Visual calculated value
2437 auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2438 int tc = (test_case + tc_offset);
2439 int idx_easing = tc % 4;
2441 int idx_motion = tc % 2;
2443 int idx_loop_count = tc % 3;
2445 int idx_direction = tc % 2;
2447 int idx_delay = tc % 4;
2450 float duration = _duration - _repeat_delay;
2451 float repeat_delay = _repeat_delay;
2452 float delay = _delay[idx_delay] * _duration;
2453 int direction = _direction[idx_direction];
2454 int loop_count = _loop_count[idx_loop_count];
2455 int motion = _motion[idx_motion];
2456 int easing = _easing[idx_easing];
2458 progress -= delay / _duration;
2460 Property::Value s = start;
2461 Property::Value t = target;
2467 float x; ///< Animator progress value
2472 else if(loop_count > 0 && progress + 0.01f > loop_count)
2474 x = (motion == 0) ? 1.0f : 0.0f;
2482 progress = fmodf(progress, 1.0f);
2483 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2488 x = progress * 2.0f;
2495 if(easing == 1) // EASE_IN
2499 else if(easing == 2) // EASE_OUT
2501 x = 2.0f * x - x * x;
2503 else if(easing == 3) // EASE_IN_OUT
2505 x = x * x * (3.0f - 2.0f * x);
2508 if(value_type == 0) // result type is Float
2512 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2513 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2514 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2516 else if(value_type == 1) // result type is Vector2
2520 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2521 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2522 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2524 else if(value_type == 2) // result type is Vector3
2528 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2529 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2530 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2532 else // result type is Vector4
2536 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2537 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2538 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2543 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2545 for(int step_iter = 0; step_iter < 3; step_iter++)
2547 application.SendNotification();
2548 application.Render(_duration * 250.f); // step i/4
2549 application.SendNotification();
2552 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2553 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2554 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2555 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2556 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2557 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2558 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2560 application.SendNotification();
2561 application.Render(_duration * 250.f); // step 4/4 will not test
2562 application.SendNotification();
2566 application.SendNotification();
2568 application.SendNotification();
2569 application.Render(10.f); // tempral time
2570 application.SendNotification();
2577 int UtcDaliVisualAnimatedGradientVisual03(void)
2579 ToolkitTestApplication application;
2580 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2582 static std::vector<UniformData> customUniforms =
2584 UniformData("start_point", Property::Type::VECTOR2),
2585 UniformData("end_point", Property::Type::VECTOR2),
2586 UniformData("start_color", Property::Type::VECTOR4),
2587 UniformData("end_color", Property::Type::VECTOR4),
2588 UniformData("rotate_center", Property::Type::VECTOR2),
2589 UniformData("rotate_angle", Property::Type::FLOAT),
2590 UniformData("gradient_offset", Property::Type::FLOAT),
2593 TestGraphicsController& graphics = application.GetGraphicsController();
2594 graphics.AddCustomUniforms(customUniforms);
2597 float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2598 int _direction[2] = {0, 1};
2599 int _loop_count[3] = {-1, 0, 1};
2600 int _motion[2] = {0, 1};
2601 int _easing[4] = {0, 1, 2, 3};
2603 int test_case_max = 4 * 2 * 3 * 2 * 4;
2605 int test_case_d = 7; // 7 is the number of animated properties.
2607 float _duration = 0.4f;
2608 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2609 float noise_maker = 0.2f;
2610 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2611 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2613 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2615 VisualFactory factory = VisualFactory::Get();
2616 Property::Map propertyMap;
2617 Property::Map animationMap;
2618 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2620 auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2621 int tc = (test_case + tc_offset);
2622 int idx_easing = tc % 4;
2624 int idx_motion = tc % 2;
2626 int idx_loop_count = tc % 3;
2628 int idx_direction = tc % 2;
2630 int idx_delay = tc % 4;
2633 float duration = _duration - _repeat_delay;
2634 float repeat_delay = _repeat_delay;
2635 float delay = _delay[idx_delay] * _duration;
2636 int direction = _direction[idx_direction];
2637 int loop_count = _loop_count[idx_loop_count];
2638 int motion = _motion[idx_motion];
2639 int easing = _easing[idx_easing];
2641 animationMap.Clear();
2642 animationMap.Insert("startValue", start);
2643 animationMap.Insert("targetValue", target);
2646 animationMap.Insert("directionType", "FORWARD");
2650 animationMap.Insert("directionType", "BACKWARD");
2652 animationMap.Insert("duration", duration);
2653 animationMap.Insert("delay", delay);
2654 animationMap.Insert("repeat", loop_count);
2655 animationMap.Insert("repeatDelay", repeat_delay);
2658 animationMap.Insert("motionType", "LOOP");
2662 animationMap.Insert("motionType", "MIRROR");
2666 animationMap.Insert("easingType", "LINEAR");
2668 else if(easing == 1)
2670 animationMap.Insert("easingType", "IN");
2672 else if(easing == 2)
2674 animationMap.Insert("easingType", "OUT");
2678 animationMap.Insert("easingType", "IN_OUT");
2681 return animationMap;
2684 // Give different values for debuging
2685 noise_maker += 0.8f;
2686 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2687 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2688 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2689 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2690 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2691 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2692 float offset1 = 0.f + noise_maker * 0.1f;
2694 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2695 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2696 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2697 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2698 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2699 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2700 float offset2 = 2.f + noise_maker * 0.1f;
2702 propertyMap.Insert("gradientType", "LINEAR");
2703 propertyMap.Insert("unitType", "USER_SPACE");
2704 propertyMap.Insert("spreadType", "CLAMP");
2706 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2707 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2708 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2709 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2710 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2711 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2712 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2714 Visual::Base visual = factory.CreateVisual(propertyMap);
2716 DummyControl actor = DummyControl::New(true);
2717 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2718 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2719 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2720 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2721 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2722 application.GetScene().Add(actor);
2724 application.SendNotification();
2725 application.Render(0);
2726 application.SendNotification();
2728 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2730 application.SendNotification();
2732 //Compare between CPU calculated value and Shader Visual calculated value
2733 auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2734 int tc = (test_case + tc_offset);
2735 int idx_easing = tc % 4;
2737 int idx_motion = tc % 2;
2739 int idx_loop_count = tc % 3;
2741 int idx_direction = tc % 2;
2743 int idx_delay = tc % 4;
2746 float duration = _duration - _repeat_delay;
2747 float repeat_delay = _repeat_delay;
2748 float delay = _delay[idx_delay] * _duration;
2749 int direction = _direction[idx_direction];
2750 int loop_count = _loop_count[idx_loop_count];
2751 int motion = _motion[idx_motion];
2752 int easing = _easing[idx_easing];
2754 progress -= delay / _duration;
2756 Property::Value s = start;
2757 Property::Value t = target;
2763 float x; ///< Animator progress value
2768 else if(loop_count > 0 && progress + 0.01f > loop_count)
2770 x = (motion == 0) ? 1.0f : 0.0f;
2778 progress = fmodf(progress, 1.0f);
2779 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2784 x = progress * 2.0f;
2791 if(easing == 1) // EASE_IN
2795 else if(easing == 2) // EASE_OUT
2797 x = 2.0f * x - x * x;
2799 else if(easing == 3) // EASE_IN_OUT
2801 x = x * x * (3.0f - 2.0f * x);
2804 if(value_type == 0) // result type is Float
2808 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2809 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2810 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2812 else if(value_type == 1) // result type is Vector2
2816 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2817 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2818 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2820 else if(value_type == 2) // result type is Vector3
2824 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2825 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2826 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2828 else // result type is Vector4
2832 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2833 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2834 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2839 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2841 for(int step_iter = 0; step_iter < 3; step_iter++)
2843 application.SendNotification();
2844 application.Render(_duration * 250.f); // step i/4
2845 application.SendNotification();
2848 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2849 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2850 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2851 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2852 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2853 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2854 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2856 application.SendNotification();
2857 application.Render(_duration * 250.f); // step 4/4 will not test
2858 application.SendNotification();
2862 application.SendNotification();
2864 application.SendNotification();
2865 application.Render(10.f); // tempral time
2866 application.SendNotification();
2873 int UtcDaliVisualWireframeVisual(void)
2875 ToolkitTestApplication application;
2877 VisualFactory factory = VisualFactory::Get();
2878 Property::Map propertyMap;
2879 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2881 // Create the visual.
2882 Visual::Base visual = factory.CreateVisual(propertyMap);
2884 DALI_TEST_CHECK(visual);
2886 Property::Map resultMap;
2887 visual.CreatePropertyMap(resultMap);
2889 // Check the property values from the returned map from visual
2890 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2891 DALI_TEST_CHECK(value);
2892 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2897 int UtcDaliVisualGetTransform(void)
2899 ToolkitTestApplication application;
2900 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2902 VisualFactory factory = VisualFactory::Get();
2903 Property::Map propertyMap;
2904 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2905 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2906 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2908 Dali::Property::Map visualMap;
2909 colorVisual.CreatePropertyMap(visualMap);
2910 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2911 Dali::Property::Map* map = value->GetMap();
2912 DALI_TEST_CHECK(map);
2914 //Test default values
2916 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2917 DALI_TEST_CHECK(typeValue);
2918 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2921 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2922 DALI_TEST_CHECK(typeValue);
2923 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2926 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2927 DALI_TEST_CHECK(typeValue);
2928 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2931 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2932 DALI_TEST_CHECK(typeValue);
2933 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2936 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2937 DALI_TEST_CHECK(typeValue);
2938 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2941 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2942 DALI_TEST_CHECK(typeValue);
2943 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2946 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2947 DALI_TEST_CHECK(typeValue);
2948 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2954 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2956 Property::Map transform;
2957 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2958 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2959 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2960 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2961 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2962 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2964 visual.SetTransformAndSize(transform, Vector2(100, 100));
2966 Dali::Property::Map visualMap;
2967 visual.CreatePropertyMap(visualMap);
2968 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2969 Dali::Property::Map* map = value->GetMap();
2970 DALI_TEST_CHECK(map);
2973 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2974 DALI_TEST_CHECK(typeValue);
2975 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2978 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2979 DALI_TEST_CHECK(typeValue);
2980 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2983 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2984 DALI_TEST_CHECK(typeValue);
2985 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2988 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2989 DALI_TEST_CHECK(typeValue);
2990 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2993 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2994 DALI_TEST_CHECK(typeValue);
2995 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2998 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2999 DALI_TEST_CHECK(typeValue);
3000 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
3003 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
3004 DALI_TEST_CHECK(typeValue);
3005 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
3008 //Put the visual on the stage
3009 DummyControl actor = DummyControl::New(true);
3010 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
3011 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3012 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3013 application.GetScene().Add(actor);
3015 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3016 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
3018 application.SendNotification();
3019 application.Render(0);
3020 Renderer renderer(actor.GetRendererAt(0));
3022 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
3023 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
3025 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
3026 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
3028 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
3029 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
3031 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3032 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
3034 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3035 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3037 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3038 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
3040 //Set a new transform
3042 transform = DefaultTransform();
3043 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
3044 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
3045 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
3046 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
3047 visual.SetTransformAndSize(transform, Vector2(100, 100));
3048 application.SendNotification();
3049 application.Render(0);
3051 //Check that the values have changed in the renderer
3052 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
3053 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
3055 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
3056 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
3058 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
3059 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
3061 //Parent origin and anchor point should have the default values
3062 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3063 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3065 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3066 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
3068 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3069 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
3072 int UtcDaliVisualSetTransform01(void)
3074 ToolkitTestApplication application;
3075 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3077 VisualFactory factory = VisualFactory::Get();
3078 Property::Map propertyMap;
3079 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3080 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
3081 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3082 Visual::Base visual = factory.CreateVisual(propertyMap);
3083 TestTransform(application, visual);
3084 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3089 int UtcDaliVisualSetTransform0(void)
3091 ToolkitTestApplication application;
3092 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3094 VisualFactory factory = VisualFactory::Get();
3095 Property::Map propertyMap;
3096 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3097 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3098 Visual::Base visual = factory.CreateVisual(propertyMap);
3099 TestTransform(application, visual);
3100 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3105 int UtcDaliVisualSetTransform1(void)
3107 ToolkitTestApplication application;
3108 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3110 VisualFactory factory = VisualFactory::Get();
3111 Property::Map propertyMap;
3112 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3113 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3114 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3115 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3116 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3117 Visual::Base visual = factory.CreateVisual(propertyMap);
3118 TestTransform(application, visual);
3119 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3124 int UtcDaliVisualSetTransform2(void)
3126 ToolkitTestApplication application;
3127 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3129 VisualFactory factory = VisualFactory::Get();
3130 Property::Map propertyMap;
3131 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3132 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3134 Property::Array stopOffsets;
3135 stopOffsets.PushBack(0.0f);
3136 stopOffsets.PushBack(0.3f);
3137 stopOffsets.PushBack(0.6f);
3138 stopOffsets.PushBack(0.8f);
3139 stopOffsets.PushBack(1.0f);
3140 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3142 Property::Array stopColors;
3143 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3144 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3145 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3146 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3147 stopColors.PushBack(Color::YELLOW);
3148 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3149 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3150 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3151 Visual::Base visual = factory.CreateVisual(propertyMap);
3152 TestTransform(application, visual);
3153 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3158 int UtcDaliVisualSetTransform3(void)
3160 ToolkitTestApplication application;
3161 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3163 VisualFactory factory = VisualFactory::Get();
3164 Property::Map propertyMap;
3165 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3166 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3167 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3168 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3169 Visual::Base visual = factory.CreateVisual(propertyMap);
3170 TestTransform(application, visual);
3171 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3176 int UtcDaliVisualSetTransform4(void)
3178 ToolkitTestApplication application;
3179 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3181 VisualFactory factory = VisualFactory::Get();
3182 Property::Map propertyMap;
3183 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3184 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3186 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3187 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3188 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3189 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3190 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3191 Visual::Base visual = factory.CreateVisual(propertyMap);
3192 TestTransform(application, visual);
3193 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3198 int UtcDaliVisualSetTransform5(void)
3200 ToolkitTestApplication application;
3201 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3203 VisualFactory factory = VisualFactory::Get();
3204 Property::Map propertyMap;
3205 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3206 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3207 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3208 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3209 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3210 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3211 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3212 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3213 Visual::Base visual = factory.CreateVisual(propertyMap);
3214 TestTransform(application, visual);
3215 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3220 int UtcDaliVisualSetTransform6(void)
3222 ToolkitTestApplication application;
3223 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3225 VisualFactory factory = VisualFactory::Get();
3226 Property::Map propertyMap;
3227 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3228 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3229 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3230 Visual::Base visual = factory.CreateVisual(propertyMap);
3231 TestTransform(application, visual);
3232 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3237 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3239 ToolkitTestApplication application;
3240 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3242 VisualFactory factory = VisualFactory::Get();
3243 Property::Map propertyMap;
3244 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3245 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3246 Visual::Base visual = factory.CreateVisual(propertyMap);
3248 Property::Map transform;
3249 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3250 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3251 visual.SetTransformAndSize(transform, Vector2(100, 100));
3253 Dali::Property::Map visualMap;
3254 visual.CreatePropertyMap(visualMap);
3255 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3256 Dali::Property::Map* map = value->GetMap();
3257 DALI_TEST_CHECK(map);
3260 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3261 DALI_TEST_CHECK(typeValue);
3262 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3265 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3266 DALI_TEST_CHECK(typeValue);
3267 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3273 int UtcDaliNPatchVisualCustomShader(void)
3275 ToolkitTestApplication application;
3276 tet_infoline("NPatchVisual with custom shader");
3278 VisualFactory factory = VisualFactory::Get();
3279 Property::Map properties;
3280 Property::Map shader;
3281 const std::string vertexShader = "Foobar";
3282 const std::string fragmentShader = "Foobar";
3283 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3284 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3286 Property::Map transformMap;
3287 transformMap["size"] = Vector2(0.5f, 0.5f);
3288 transformMap["offset"] = Vector2(20.0f, 0.0f);
3289 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3290 transformMap["anchorPoint"] = Align::CENTER;
3291 transformMap["origin"] = Align::CENTER;
3292 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3293 properties[Visual::Property::TRANSFORM] = transformMap;
3295 properties[Visual::Property::TYPE] = Visual::IMAGE;
3296 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3297 properties[Visual::Property::SHADER] = shader;
3298 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3299 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3301 Visual::Base visual = factory.CreateVisual(properties);
3302 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3304 // trigger creation through setting on stage
3305 DummyControl dummy = DummyControl::New(true);
3306 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3307 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3308 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3309 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3310 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3311 application.GetScene().Add(dummy);
3312 application.SendNotification();
3314 Renderer renderer = dummy.GetRendererAt(0);
3315 Shader shader2 = renderer.GetShader();
3316 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3317 Property::Map* map = value.GetMap();
3318 DALI_TEST_CHECK(map);
3320 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3321 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3323 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3324 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3326 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3327 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3329 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3330 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3335 int UtcDaliGradientVisualBlendMode(void)
3337 ToolkitTestApplication application;
3338 VisualFactory factory = VisualFactory::Get();
3340 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3341 Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Color::GREEN)));
3343 Visual::Base alphaGradientVisual = factory.CreateVisual(
3344 Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3346 DummyControl control = DummyControl::New(true);
3347 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3348 application.GetScene().Add(control);
3350 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3351 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3352 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3354 application.SendNotification();
3355 application.Render();
3357 // 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
3358 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3359 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3360 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3365 int UtcDaliVisualRendererRemovalAndReAddition(void)
3367 ToolkitTestApplication application;
3368 tet_infoline("UtcDaliVisualRendererRemoval");
3370 VisualFactory factory = VisualFactory::Get();
3371 Property::Map propertyMap;
3372 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3373 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3374 Visual::Base visual = factory.CreateVisual(propertyMap);
3376 visual.SetDepthIndex(1);
3378 DummyControl dummyControl = DummyControl::New(true);
3379 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3380 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3381 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3383 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3384 tet_infoline("Add control with visual to stage and check renderer count is 1");
3386 application.GetScene().Add(dummyControl);
3388 application.SendNotification();
3389 application.Render();
3391 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3393 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3394 application.GetScene().Remove(dummyControl);
3395 application.SendNotification();
3396 application.Render();
3398 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3400 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3402 application.GetScene().Add(dummyControl);
3404 application.SendNotification();
3405 application.Render();
3407 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3412 int UtcDaliVisualTextVisualRender(void)
3414 ToolkitTestApplication application;
3415 tet_infoline("UtcDaliVisualTextVisualRender");
3417 VisualFactory factory = VisualFactory::Get();
3418 Property::Map propertyMap;
3419 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3420 propertyMap.Insert("mixColor", Color::WHITE);
3421 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3422 propertyMap.Insert("enableMarkup", false);
3423 propertyMap.Insert("text", "Hello world");
3424 propertyMap.Insert("fontFamily", "TizenSans");
3426 Property::Map fontStyleMapSet;
3427 fontStyleMapSet.Insert("weight", "bold");
3428 propertyMap.Insert("fontStyle", fontStyleMapSet);
3430 propertyMap.Insert("pointSize", 12.f);
3431 propertyMap.Insert("multiLine", true);
3432 propertyMap.Insert("horizontalAlignment", "CENTER");
3433 propertyMap.Insert("verticalAlignment", "CENTER");
3434 propertyMap.Insert("textColor", Color::RED);
3435 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3436 textVisual.SetDepthIndex(1);
3438 DummyControl dummyControl = DummyControl::New(true);
3439 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3440 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3441 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3443 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3444 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3446 application.GetScene().Add(dummyControl);
3447 application.SendNotification();
3448 application.Render();
3450 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3451 propertyMap.Clear();
3452 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3453 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3454 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3455 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3457 Property::Map transformMap;
3458 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3459 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3461 textVisual = factory.CreateVisual(propertyMap);
3462 textVisual.SetDepthIndex(1);
3464 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3465 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3467 application.SendNotification(); // force process events to ensure text visual
3468 // adds renderer to the dummy control in OnRelayout
3469 application.Render();
3471 Renderer renderer = dummyControl.GetRendererAt(0u);
3472 Property::Index index = renderer.GetPropertyIndex("transformSize");
3474 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3475 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3480 int UtcDaliVisualTextVisualDisableEnable(void)
3482 ToolkitTestApplication application;
3483 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3485 VisualFactory factory = VisualFactory::Get();
3486 Property::Map propertyMap;
3487 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3488 propertyMap.Insert("mixColor", Color::WHITE);
3489 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3490 propertyMap.Insert("enableMarkup", false);
3491 propertyMap.Insert("text", "Hello world");
3492 propertyMap.Insert("fontFamily", "TizenSans");
3494 Property::Map fontStyleMapSet;
3495 fontStyleMapSet.Insert("weight", "bold");
3496 propertyMap.Insert("fontStyle", fontStyleMapSet);
3498 propertyMap.Insert("pointSize", 12.f);
3499 propertyMap.Insert("multiLine", true);
3500 propertyMap.Insert("horizontalAlignment", "CENTER");
3501 propertyMap.Insert("verticalAlignment", "CENTER");
3502 propertyMap.Insert("textColor", Color::RED);
3503 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3504 textVisual.SetDepthIndex(1);
3506 DummyControl dummyControl = DummyControl::New(true);
3507 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3508 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3509 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3511 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3512 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3514 application.GetScene().Add(dummyControl);
3515 application.SendNotification();
3516 application.Render();
3518 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3520 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3522 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3524 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3526 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3531 int UtcDaliVisualPremultipliedAlpha(void)
3533 ToolkitTestApplication application;
3534 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3536 VisualFactory factory = VisualFactory::Get();
3538 // image visual, test default value ( true )
3540 Visual::Base imageVisual = factory.CreateVisual(
3542 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3543 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3545 Dali::Property::Map visualMap;
3546 imageVisual.CreatePropertyMap(visualMap);
3547 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3550 DALI_TEST_CHECK(value);
3551 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3554 // image visual, override premultiplied
3556 Visual::Base imageVisual = factory.CreateVisual(
3558 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3559 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3560 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3562 Dali::Property::Map visualMap;
3563 imageVisual.CreatePropertyMap(visualMap);
3564 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3567 DALI_TEST_CHECK(value);
3568 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3571 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3573 Visual::Base imageVisual = factory.CreateVisual(
3575 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3576 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3578 Dali::Property::Map visualMap;
3579 imageVisual.CreatePropertyMap(visualMap);
3580 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3583 DALI_TEST_CHECK(value);
3584 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3587 Visual::Base imageVisual = factory.CreateVisual(
3589 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3590 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3591 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3593 Dali::Property::Map visualMap;
3594 imageVisual.CreatePropertyMap(visualMap);
3595 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3598 DALI_TEST_CHECK(value);
3599 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3602 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3604 Visual::Base imageVisual = factory.CreateVisual(
3606 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3607 .Add(ImageVisual::Property::URL, "something.json"));
3609 Dali::Property::Map visualMap;
3610 imageVisual.CreatePropertyMap(visualMap);
3611 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3614 DALI_TEST_CHECK(value);
3615 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3618 Visual::Base imageVisual = factory.CreateVisual(
3620 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3621 .Add(ImageVisual::Property::URL, "something.json")
3622 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3624 Dali::Property::Map visualMap;
3625 imageVisual.CreatePropertyMap(visualMap);
3626 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3629 DALI_TEST_CHECK(value);
3630 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3633 // text visual ( premultiplied alpha by default is true, and cannot change value )
3635 Visual::Base textVisual = factory.CreateVisual(
3637 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3638 .Add(TextVisual::Property::TEXT, "Text"));
3640 Dali::Property::Map visualMap;
3641 textVisual.CreatePropertyMap(visualMap);
3642 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3645 DALI_TEST_CHECK(value);
3646 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3649 Visual::Base textVisual = factory.CreateVisual(
3651 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3652 .Add(TextVisual::Property::TEXT, "Text")
3653 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3655 Dali::Property::Map visualMap;
3656 textVisual.CreatePropertyMap(visualMap);
3657 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3660 DALI_TEST_CHECK(value);
3661 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3664 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3666 Visual::Base gradientVisual = factory.CreateVisual(
3668 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3669 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3670 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3671 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3673 Dali::Property::Map visualMap;
3674 gradientVisual.CreatePropertyMap(visualMap);
3675 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3678 DALI_TEST_CHECK(value);
3679 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3682 Visual::Base gradientVisual = factory.CreateVisual(
3684 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3685 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3686 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3687 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3688 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3690 Dali::Property::Map visualMap;
3691 gradientVisual.CreatePropertyMap(visualMap);
3692 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3695 DALI_TEST_CHECK(value);
3696 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3699 // color visual ( premultiplied alpha by default is false, and cannot change value )
3701 Visual::Base colorVisual = factory.CreateVisual(
3703 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3704 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3706 Dali::Property::Map visualMap;
3707 colorVisual.CreatePropertyMap(visualMap);
3708 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3711 DALI_TEST_CHECK(value);
3712 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3715 Visual::Base colorVisual = factory.CreateVisual(
3717 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3718 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3719 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3721 Dali::Property::Map visualMap;
3722 colorVisual.CreatePropertyMap(visualMap);
3723 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3726 DALI_TEST_CHECK(value);
3727 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3733 int UtcDaliRegisterVisualOrder(void)
3735 ToolkitTestApplication application;
3736 tet_infoline("Register Visual Order");
3738 DummyControl dummyControl = DummyControl::New(true);
3739 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3741 VisualFactory factory = VisualFactory::Get();
3742 Property::Map propertyMap;
3743 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3744 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3746 tet_infoline("Register visual, should have depth index of 0.0f");
3747 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3748 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3749 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3751 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3753 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3754 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3755 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3757 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3758 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3759 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3761 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3762 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3763 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3765 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3766 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3767 labelVisual.SetDepthIndex(-2000);
3768 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3769 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3771 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3772 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3773 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3774 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3775 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3776 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3778 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3779 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3780 anotherTestVisual2Replacement.SetDepthIndex(2000);
3781 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3782 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3784 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3785 application.GetScene().Add(dummyControl);
3790 int UtcDaliRegisterVisualOrder02(void)
3792 ToolkitTestApplication application;
3793 tet_infoline("Register Visual Order with Background Set");
3795 DummyControl dummyControl = DummyControl::New(true);
3796 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3798 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3800 VisualFactory factory = VisualFactory::Get();
3801 Property::Map propertyMap;
3802 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3803 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3805 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3807 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3809 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3810 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3811 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3812 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3813 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3815 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3816 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3817 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3818 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3820 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3821 application.GetScene().Add(dummyControl);
3826 int UtcDaliRegisterVisualWithDepthIndex(void)
3828 ToolkitTestApplication application;
3829 tet_infoline("Register a Visual With Depth Index");
3831 DummyControl dummyControl = DummyControl::New(true);
3832 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3834 VisualFactory factory = VisualFactory::Get();
3835 Property::Map propertyMap;
3836 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3837 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3839 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3840 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3841 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3842 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3843 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3845 tet_infoline("Register another visual with a depth index and it disabled");
3846 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3847 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3848 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3849 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3851 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3852 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3853 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3854 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3855 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3857 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3858 application.GetScene().Add(dummyControl);
3863 int UtcDaliSvgVisualCustomShader(void)
3865 ToolkitTestApplication application;
3866 tet_infoline("SvgVisual with custom shader");
3868 VisualFactory factory = VisualFactory::Get();
3869 Property::Map properties;
3870 Property::Map shader;
3871 const std::string vertexShader = "Foobar";
3872 const std::string fragmentShader = "Foobar";
3873 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3874 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3876 properties[Visual::Property::TYPE] = Visual::IMAGE;
3877 properties[Visual::Property::SHADER] = shader;
3878 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3880 Visual::Base visual = factory.CreateVisual(properties);
3882 // trigger creation through setting on stage
3883 DummyControl dummy = DummyControl::New(true);
3884 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3885 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3887 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3888 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3889 application.GetScene().Add(dummy);
3891 application.SendNotification();
3892 application.Render();
3894 // Wait for loading & rasterization
3895 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3897 Renderer renderer = dummy.GetRendererAt(0);
3898 Shader shader2 = renderer.GetShader();
3899 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3900 Property::Map* map = value.GetMap();
3901 DALI_TEST_CHECK(map);
3903 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3904 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3906 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3907 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3912 int UtcDaliVisualRoundedCorner(void)
3914 tet_infoline("UtcDaliVisualRoundedCorner");
3916 static std::vector<UniformData> customUniforms =
3918 UniformData("cornerRadius", Property::Type::VECTOR4),
3919 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3924 ToolkitTestApplication application;
3925 TestGraphicsController& graphics = application.GetGraphicsController();
3926 graphics.AddCustomUniforms(customUniforms);
3928 VisualFactory factory = VisualFactory::Get();
3929 Property::Map properties;
3930 float cornerRadius = 30.0f;
3932 properties[Visual::Property::TYPE] = Visual::IMAGE;
3933 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3934 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3936 Visual::Base visual = factory.CreateVisual(properties);
3938 // trigger creation through setting on stage
3939 DummyControl dummy = DummyControl::New(true);
3940 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3941 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3943 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3944 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3945 application.GetScene().Add(dummy);
3947 application.SendNotification();
3948 application.Render();
3950 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3952 application.SendNotification();
3953 application.Render();
3955 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3956 // Default corner radius policy is absolute.
3957 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3962 ToolkitTestApplication application;
3963 TestGraphicsController& graphics = application.GetGraphicsController();
3964 graphics.AddCustomUniforms(customUniforms);
3966 VisualFactory factory = VisualFactory::Get();
3967 Property::Map properties;
3968 float cornerRadius = 30.0f;
3970 properties[Visual::Property::TYPE] = Visual::COLOR;
3971 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3972 properties["cornerRadius"] = cornerRadius;
3973 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3975 Visual::Base visual = factory.CreateVisual(properties);
3977 // trigger creation through setting on stage
3978 DummyControl dummy = DummyControl::New(true);
3979 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3980 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3982 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3983 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3984 application.GetScene().Add(dummy);
3986 application.SendNotification();
3987 application.Render();
3989 application.SendNotification();
3990 application.Render();
3992 // Currently test with multiple program doesn't work well. will fix another day
3993 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3994 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3999 ToolkitTestApplication application;
4000 TestGraphicsController& graphics = application.GetGraphicsController();
4001 graphics.AddCustomUniforms(customUniforms);
4003 VisualFactory factory = VisualFactory::Get();
4004 Property::Map properties;
4005 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
4007 properties[Visual::Property::TYPE] = Visual::COLOR;
4008 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4009 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4010 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4012 Visual::Base visual = factory.CreateVisual(properties);
4014 // trigger creation through setting on stage
4015 DummyControl dummy = DummyControl::New(true);
4016 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4017 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4019 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4020 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4021 application.GetScene().Add(dummy);
4023 application.SendNotification();
4024 application.Render();
4026 application.SendNotification();
4027 application.Render();
4029 // Currently test with multiple program doesn't work well. will fix another day
4030 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4031 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4034 // color visual 3 - invalid value
4036 ToolkitTestApplication application;
4037 TestGraphicsController& graphics = application.GetGraphicsController();
4038 graphics.AddCustomUniforms(customUniforms);
4040 VisualFactory factory = VisualFactory::Get();
4041 Property::Map properties;
4042 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
4044 properties[Visual::Property::TYPE] = Visual::COLOR;
4045 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4046 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4047 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
4049 Visual::Base visual = factory.CreateVisual(properties);
4051 // trigger creation through setting on stage
4052 DummyControl dummy = DummyControl::New(true);
4053 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4054 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4056 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4057 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4058 application.GetScene().Add(dummy);
4060 application.SendNotification();
4061 application.Render();
4063 application.SendNotification();
4064 application.Render();
4066 // Currently test with multiple program doesn't work well. will fix another day
4067 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4068 // Default corner radius policy is absolute.
4069 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4074 ToolkitTestApplication application;
4075 TestGraphicsController& graphics = application.GetGraphicsController();
4076 graphics.AddCustomUniforms(customUniforms);
4078 VisualFactory factory = VisualFactory::Get();
4079 Property::Map properties;
4080 float cornerRadius = 30.0f;
4082 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4083 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4084 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4085 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4086 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4087 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4089 Property::Array stopOffsets;
4090 stopOffsets.PushBack(0.0f);
4091 stopOffsets.PushBack(0.6f);
4092 stopOffsets.PushBack(1.0f);
4093 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4095 Property::Array stopColors;
4096 stopColors.PushBack(Color::RED);
4097 stopColors.PushBack(Color::YELLOW);
4098 stopColors.PushBack(Color::GREEN);
4099 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4101 Visual::Base visual = factory.CreateVisual(properties);
4103 // trigger creation through setting on stage
4104 DummyControl dummy = DummyControl::New(true);
4105 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4106 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4108 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4109 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4110 application.GetScene().Add(dummy);
4112 application.SendNotification();
4113 application.Render();
4115 application.SendNotification();
4116 application.Render();
4118 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4119 // Default corner radius policy is absolute.
4120 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4123 // animated image visual
4125 ToolkitTestApplication application;
4126 TestGraphicsController& graphics = application.GetGraphicsController();
4127 graphics.AddCustomUniforms(customUniforms);
4129 VisualFactory factory = VisualFactory::Get();
4130 Property::Map properties;
4131 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4133 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4134 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4135 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4136 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4137 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4139 Visual::Base visual = factory.CreateVisual(properties);
4141 // trigger creation through setting on stage
4142 DummyControl dummy = DummyControl::New(true);
4143 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4144 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4146 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4147 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4148 application.GetScene().Add(dummy);
4150 application.SendNotification();
4151 application.Render();
4153 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4155 application.SendNotification();
4156 application.Render();
4158 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4159 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4162 // vector image visual
4164 ToolkitTestApplication application;
4165 TestGraphicsController& graphics = application.GetGraphicsController();
4166 graphics.AddCustomUniforms(customUniforms);
4168 VisualFactory factory = VisualFactory::Get();
4169 Property::Map properties;
4170 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4172 properties[Visual::Property::TYPE] = Visual::SVG;
4173 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4174 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4176 Visual::Base visual = factory.CreateVisual(properties);
4178 // trigger creation through setting on stage
4179 DummyControl dummy = DummyControl::New(true);
4180 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4181 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4183 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4184 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4185 application.GetScene().Add(dummy);
4187 application.SendNotification();
4188 application.Render();
4190 // Wait for loading & rasterization
4191 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4193 application.SendNotification();
4194 application.Render();
4196 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4197 // Default corner radius policy is absolute.
4198 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4201 // animated vector image visual
4203 ToolkitTestApplication application;
4204 TestGraphicsController& graphics = application.GetGraphicsController();
4205 graphics.AddCustomUniforms(customUniforms);
4207 VisualFactory factory = VisualFactory::Get();
4208 Property::Map properties;
4209 float cornerRadius = 1.3f;
4211 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4212 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4213 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4214 properties["cornerRadius"] = cornerRadius;
4215 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4216 properties["synchronousLoading"] = false;
4218 Visual::Base visual = factory.CreateVisual(properties);
4220 // trigger creation through setting on stage
4221 DummyControl dummy = DummyControl::New(true);
4222 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4223 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4225 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4226 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4227 application.GetScene().Add(dummy);
4229 application.SendNotification();
4230 application.Render();
4232 // Trigger count is 2 - load & render a frame
4233 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4235 application.SendNotification();
4236 application.Render();
4238 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4239 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4245 int UtcDaliVisualBorderline(void)
4247 tet_infoline("UtcDaliVisualBorderline");
4249 static std::vector<UniformData> customUniforms =
4251 UniformData("cornerRadius", Property::Type::VECTOR4),
4252 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4253 UniformData("borderlineWidth", Property::Type::FLOAT),
4254 UniformData("borderlineColor", Property::Type::VECTOR4),
4255 UniformData("borderlineOffset", Property::Type::FLOAT),
4260 ToolkitTestApplication application;
4261 TestGraphicsController& graphics = application.GetGraphicsController();
4262 graphics.AddCustomUniforms(customUniforms);
4264 VisualFactory factory = VisualFactory::Get();
4265 Property::Map properties;
4266 float cornerRadius = 5.0f;
4267 float borderlineWidth = 30.0f;
4268 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4269 float borderlineOffset = 1.0f;
4271 properties[Visual::Property::TYPE] = Visual::IMAGE;
4272 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4273 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4274 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4275 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4276 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4278 Visual::Base visual = factory.CreateVisual(properties);
4280 // trigger creation through setting on stage
4281 DummyControl dummy = DummyControl::New(true);
4282 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4283 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4285 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4286 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4287 application.GetScene().Add(dummy);
4289 application.SendNotification();
4290 application.Render();
4292 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4294 application.SendNotification();
4295 application.Render();
4297 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4298 // Default corner radius policy is absolute.
4299 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4300 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4301 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4302 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4307 ToolkitTestApplication application;
4308 TestGraphicsController& graphics = application.GetGraphicsController();
4309 graphics.AddCustomUniforms(customUniforms);
4311 VisualFactory factory = VisualFactory::Get();
4312 Property::Map properties;
4313 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4314 float borderlineWidth = 30.0f;
4315 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4316 float borderlineOffset = -0.4f;
4318 properties[Visual::Property::TYPE] = Visual::COLOR;
4319 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4320 properties["cornerRadius"] = cornerRadius;
4321 properties["borderlineWidth"] = borderlineWidth;
4322 properties["borderlineColor"] = borderlineColor;
4323 properties["borderlineOffset"] = borderlineOffset;
4325 Visual::Base visual = factory.CreateVisual(properties);
4327 // trigger creation through setting on stage
4328 DummyControl dummy = DummyControl::New(true);
4329 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4330 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4332 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4333 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4334 application.GetScene().Add(dummy);
4336 application.SendNotification();
4337 application.Render();
4339 application.SendNotification();
4340 application.Render();
4342 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4343 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4344 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4345 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4348 // color visual 2, default color, default offset
4350 ToolkitTestApplication application;
4351 TestGraphicsController& graphics = application.GetGraphicsController();
4352 graphics.AddCustomUniforms(customUniforms);
4354 VisualFactory factory = VisualFactory::Get();
4355 Property::Map properties;
4356 float borderlineWidth = 30.0f;
4358 properties[Visual::Property::TYPE] = Visual::COLOR;
4359 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4360 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4362 Visual::Base visual = factory.CreateVisual(properties);
4364 // trigger creation through setting on stage
4365 DummyControl dummy = DummyControl::New(true);
4366 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4367 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4369 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4370 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4371 application.GetScene().Add(dummy);
4373 application.SendNotification();
4374 application.Render();
4376 application.SendNotification();
4377 application.Render();
4379 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4380 // Default borderline color is BLACK.
4381 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4382 // Default borderline offset is 0.0f.
4383 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4386 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4388 ToolkitTestApplication application;
4389 TestGraphicsController& graphics = application.GetGraphicsController();
4390 graphics.AddCustomUniforms(customUniforms);
4392 VisualFactory factory = VisualFactory::Get();
4393 Property::Map properties;
4394 float borderlineWidth = 30.0f;
4395 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4396 float borderlineOffset = 37.4f;
4398 properties[Visual::Property::TYPE] = Visual::COLOR;
4399 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4400 properties["borderlineWidth"] = borderlineWidth;
4401 properties["borderlineColor"] = borderlineColor;
4402 properties["borderlineOffset"] = borderlineOffset;
4404 Visual::Base visual = factory.CreateVisual(properties);
4406 // trigger creation through setting on stage
4407 DummyControl dummy = DummyControl::New(true);
4408 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4409 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4411 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4412 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4413 application.GetScene().Add(dummy);
4415 application.SendNotification();
4416 application.Render();
4418 application.SendNotification();
4419 application.Render();
4421 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4422 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4423 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4424 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4429 ToolkitTestApplication application;
4430 TestGraphicsController& graphics = application.GetGraphicsController();
4431 graphics.AddCustomUniforms(customUniforms);
4433 VisualFactory factory = VisualFactory::Get();
4434 Property::Map properties;
4435 float borderlineWidth = 30.0f;
4436 float cornerRadius = 70.0f;
4438 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4439 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4440 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4441 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4442 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4443 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4444 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4446 Property::Array stopOffsets;
4447 stopOffsets.PushBack(0.0f);
4448 stopOffsets.PushBack(0.6f);
4449 stopOffsets.PushBack(1.0f);
4450 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4452 Property::Array stopColors;
4453 stopColors.PushBack(Color::RED);
4454 stopColors.PushBack(Color::YELLOW);
4455 stopColors.PushBack(Color::GREEN);
4456 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4458 Visual::Base visual = factory.CreateVisual(properties);
4460 // trigger creation through setting on stage
4461 DummyControl dummy = DummyControl::New(true);
4462 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4463 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4465 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4466 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4467 application.GetScene().Add(dummy);
4469 application.SendNotification();
4470 application.Render();
4472 application.SendNotification();
4473 application.Render();
4475 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4476 // Default corner radius policy is absolute.
4477 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4478 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4479 // Default borderline color is BLACK.
4480 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4481 // Default borderline offset is 0.0f.
4482 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4485 // animated image visual
4487 ToolkitTestApplication application;
4488 TestGraphicsController& graphics = application.GetGraphicsController();
4489 graphics.AddCustomUniforms(customUniforms);
4491 VisualFactory factory = VisualFactory::Get();
4492 Property::Map properties;
4493 float borderlineWidth = 24.0f;
4494 float borderlineOffset = -1.0f;
4496 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4497 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4498 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4499 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4500 properties["borderlineOffset"] = borderlineOffset;
4502 Visual::Base visual = factory.CreateVisual(properties);
4504 // trigger creation through setting on stage
4505 DummyControl dummy = DummyControl::New(true);
4506 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4507 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4509 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4510 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4511 application.GetScene().Add(dummy);
4513 application.SendNotification();
4514 application.Render();
4516 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4518 application.SendNotification();
4519 application.Render();
4521 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4522 // Default borderline color is BLACK.
4523 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4524 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4527 // vector image visual
4529 ToolkitTestApplication application;
4530 TestGraphicsController& graphics = application.GetGraphicsController();
4531 graphics.AddCustomUniforms(customUniforms);
4533 VisualFactory factory = VisualFactory::Get();
4534 Property::Map properties;
4535 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4536 float borderlineWidth = 27.0f;
4537 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4539 properties[Visual::Property::TYPE] = Visual::SVG;
4540 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4541 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4542 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4543 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4545 Visual::Base visual = factory.CreateVisual(properties);
4547 // trigger creation through setting on stage
4548 DummyControl dummy = DummyControl::New(true);
4549 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4550 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4552 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4553 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4554 application.GetScene().Add(dummy);
4556 application.SendNotification();
4557 application.Render();
4559 // Wait for loading & rasterization
4560 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4562 application.SendNotification();
4563 application.Render();
4565 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4566 // Default corner radius policy is absolute.
4567 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4568 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4569 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4570 // Default borderline offset is 0.0.
4571 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4574 // animated vector image visual
4576 ToolkitTestApplication application;
4577 TestGraphicsController& graphics = application.GetGraphicsController();
4578 graphics.AddCustomUniforms(customUniforms);
4580 VisualFactory factory = VisualFactory::Get();
4581 Property::Map properties;
4582 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4583 float borderlineWidth = 13.0f;
4584 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4585 float borderlineOffset = 13.0f;
4587 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4588 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4589 properties["cornerRadius"] = cornerRadius;
4590 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4591 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4592 properties["borderlineColor"] = borderlineColor;
4593 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4594 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = false;
4596 Visual::Base visual = factory.CreateVisual(properties);
4598 // trigger creation through setting on stage
4599 DummyControl dummy = DummyControl::New(true);
4600 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4601 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4603 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4604 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4605 application.GetScene().Add(dummy);
4607 application.SendNotification();
4608 application.Render();
4610 // Trigger count is 2 - load & render a frame
4611 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4613 application.SendNotification();
4614 application.Render();
4616 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4617 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4618 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4619 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4620 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4626 int UtcDaliVisualBorderlineBlendModeTest(void)
4628 ToolkitTestApplication application;
4629 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4630 VisualFactory factory = VisualFactory::Get();
4632 // Case 1 : Test which doesn't support borderline feature.
4634 tet_printf("Test Unsupported visual type\n");
4635 Property::Map propertyMap;
4636 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4637 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4638 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4639 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4641 DummyControl actor = DummyControl::New(true);
4642 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4643 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4644 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4645 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4646 application.GetScene().Add(actor);
4648 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4650 Renderer renderer = actor.GetRendererAt(0);
4652 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4653 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4654 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4656 application.GetScene().Remove(actor);
4659 // Case 2 : Test which support borderline feature.
4661 tet_printf("Test normal case\n");
4662 Property::Map propertyMap;
4663 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4664 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4665 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4666 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4668 DummyControl actor = DummyControl::New(true);
4669 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4670 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4671 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4672 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4673 application.GetScene().Add(actor);
4675 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4677 Renderer renderer = actor.GetRendererAt(0);
4679 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4680 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4681 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4683 application.GetScene().Remove(actor);
4686 // Case 3 : Test which animated borderline.
4688 tet_printf("Test borderline animate case\n");
4689 Property::Map propertyMap;
4690 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4691 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4692 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4694 DummyControl actor = DummyControl::New(true);
4695 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4696 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4697 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4698 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4699 application.GetScene().Add(actor);
4701 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4703 Renderer renderer = actor.GetRendererAt(0);
4705 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4706 // BlendMode is AUTO.
4707 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4709 Animation animation = Animation::New(0.1f);
4710 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4713 application.SendNotification();
4714 application.Render();
4715 application.Render(101u); // End of animation
4717 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4718 // BlendMode is ON_WITHOUT_CULL.
4719 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4721 Animation revanimation = Animation::New(0.1f);
4722 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4723 revanimation.Play();
4725 application.SendNotification();
4726 application.Render();
4727 application.Render(101u); // End of animation
4729 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4730 // BlendMode is still ON_WITHOUT_CULL.
4731 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4733 application.GetScene().Remove(actor);
4736 // Case 4 : Test which animated corner radius occur.
4738 tet_printf("Test borderline animate case\n");
4739 Property::Map propertyMap;
4740 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4741 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4742 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4743 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4745 DummyControl actor = DummyControl::New(true);
4746 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4747 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4748 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4749 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4750 application.GetScene().Add(actor);
4752 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4754 Renderer renderer = actor.GetRendererAt(0);
4756 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4757 // BlendMode is ON_WITHOUT_CULL.
4758 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4760 Animation animation = Animation::New(0.1f);
4761 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4764 application.SendNotification();
4765 application.Render();
4766 application.Render(101u); // End of animation
4768 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4769 // BlendMode is ON_WITHOUT_CULL.
4770 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4772 application.GetScene().Remove(actor);
4778 int UtcDaliVisualBorderlineColorAnimateTest(void)
4780 ToolkitTestApplication application;
4781 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4783 TestGraphicsController& graphics = application.GetGraphicsController();
4784 static std::vector<UniformData> customUniforms =
4786 UniformData("mixColor", Property::Type::VECTOR3),
4787 UniformData("cornerRadius", Property::Type::VECTOR4),
4788 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4789 UniformData("borderlineWidth", Property::Type::FLOAT),
4790 UniformData("borderlineColor", Property::Type::VECTOR4),
4791 UniformData("borderlineOffset", Property::Type::FLOAT),
4793 graphics.AddCustomUniforms(customUniforms);
4796 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4797 const float INITIAL_MIX_OPACITY(0.5f);
4798 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4799 const float INITIAL_ACTOR_OPACITY(1.0f);
4800 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4801 const float TARGET_MIX_OPACITY(0.8f);
4802 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4803 const float TARGET_ACTOR_OPACITY(0.5f);
4805 VisualFactory factory = VisualFactory::Get();
4806 Property::Map propertyMap;
4807 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4808 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4809 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4810 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4811 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4812 Visual::Base visual = factory.CreateVisual(propertyMap);
4814 DummyControl actor = DummyControl::New(true);
4815 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4816 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4817 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4818 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4819 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4820 application.GetScene().Add(actor);
4822 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4824 Animation animation = Animation::New(4.0f);
4825 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4826 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4827 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4828 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4831 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4833 application.SendNotification();
4834 application.Render(0);
4835 application.Render(2000u); // halfway point
4836 application.SendNotification();
4838 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4839 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4840 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4841 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4842 halfwayMixOpacity *= halfwayActorOpacity;
4843 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4844 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4845 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4846 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4848 application.Render(2001u); // go past end
4849 application.SendNotification(); // Trigger signals
4851 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4852 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4853 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4854 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4855 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4863 int UtcDaliColorVisualBlurRadius(void)
4865 ToolkitTestApplication application;
4866 tet_infoline("UtcDaliColorVisualBlurRadius");
4868 static std::vector<UniformData> customUniforms =
4870 UniformData("blurRadius", Property::Type::FLOAT),
4873 TestGraphicsController& graphics = application.GetGraphicsController();
4874 graphics.AddCustomUniforms(customUniforms);
4876 VisualFactory factory = VisualFactory::Get();
4877 Property::Map properties;
4878 float blurRadius = 20.0f;
4880 properties[Visual::Property::TYPE] = Visual::COLOR;
4881 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4882 properties["blurRadius"] = blurRadius;
4884 Visual::Base visual = factory.CreateVisual(properties);
4886 // trigger creation through setting on stage
4887 DummyControl dummy = DummyControl::New(true);
4888 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4889 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4891 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4892 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4893 application.GetScene().Add(dummy);
4895 application.SendNotification();
4896 application.Render();
4898 application.SendNotification();
4899 application.Render();
4901 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4906 int UtcDaliVisualGetType(void)
4908 ToolkitTestApplication application;
4909 tet_infoline("UtcDaliVisualGetType");
4911 VisualFactory factory = VisualFactory::Get();
4914 Property::Map properties;
4915 properties[Visual::Property::TYPE] = Visual::BORDER;
4916 Visual::Base visual = factory.CreateVisual(properties);
4918 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4922 Property::Map properties;
4923 properties[Visual::Property::TYPE] = Visual::COLOR;
4924 Visual::Base visual = factory.CreateVisual(properties);
4926 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4930 Property::Map properties;
4931 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4932 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4933 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4934 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4935 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4936 Property::Array stopColors;
4937 stopColors.PushBack(Color::RED);
4938 stopColors.PushBack(Color::GREEN);
4939 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4940 Visual::Base visual = factory.CreateVisual(properties);
4942 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4946 Property::Map properties;
4947 properties[Visual::Property::TYPE] = Visual::IMAGE;
4948 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4949 Visual::Base visual = factory.CreateVisual(properties);
4951 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4955 Property::Map properties;
4956 properties[Visual::Property::TYPE] = Visual::MESH;
4957 Visual::Base visual = factory.CreateVisual(properties);
4959 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4963 Property::Map properties;
4964 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4965 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4966 Visual::Base visual = factory.CreateVisual(properties);
4968 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4972 Property::Map properties;
4973 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4974 Visual::Base visual = factory.CreateVisual(properties);
4976 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4980 Property::Map properties;
4981 properties[Visual::Property::TYPE] = Visual::TEXT;
4982 Visual::Base visual = factory.CreateVisual(properties);
4984 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4988 Property::Map properties;
4989 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4990 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4991 Visual::Base visual = factory.CreateVisual(properties);
4993 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4997 Property::Map properties;
4998 properties[Visual::Property::TYPE] = Visual::SVG;
4999 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
5000 Visual::Base visual = factory.CreateVisual(properties);
5002 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
5006 Property::Map properties;
5007 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
5008 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
5009 Visual::Base visual = factory.CreateVisual(properties);
5011 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
5015 Property::Map properties;
5016 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
5017 Visual::Base visual = factory.CreateVisual(properties);
5019 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
5023 Property::Map properties;
5024 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
5025 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
5026 Visual::Base visual = factory.CreateVisual(properties);
5028 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
5032 Property::Map properties;
5033 properties[Visual::Property::TYPE] = DevelVisual::ARC;
5034 Visual::Base visual = factory.CreateVisual(properties);
5036 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
5042 int UtcDaliVisualGetVisualProperty01(void)
5044 ToolkitTestApplication application;
5045 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
5047 static std::vector<UniformData> customUniforms =
5049 UniformData("mixColor", Property::Type::VECTOR3),
5050 UniformData("offset", Property::Type::VECTOR2),
5051 UniformData("size", Property::Type::VECTOR2),
5052 UniformData("cornerRadius", Property::Type::VECTOR4),
5053 UniformData("blurRadius", Property::Type::FLOAT),
5054 UniformData("borderlineWidth", Property::Type::FLOAT),
5055 UniformData("borderlineColor", Property::Type::VECTOR4),
5056 UniformData("borderlineOffset", Property::Type::FLOAT)};
5058 TestGraphicsController& graphics = application.GetGraphicsController();
5059 graphics.AddCustomUniforms(customUniforms);
5061 VisualFactory factory = VisualFactory::Get();
5062 Property::Map propertyMap;
5063 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5064 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
5065 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
5066 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
5067 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
5068 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
5069 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
5070 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
5071 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5073 DummyControl dummyControl = DummyControl::New(true);
5074 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5075 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5076 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5077 application.GetScene().Add(dummyControl);
5079 application.SendNotification();
5080 application.Render();
5082 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5083 Vector2 targetOffset(0.05f, 0.05f);
5084 Vector2 targetSize(1.1f, 1.1f);
5085 float targetOpacity = 0.5f;
5086 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
5087 float targetBlurRadius = 10.0f;
5088 float targetBorderlineWidth = 25.0f;
5089 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
5090 float targetBorderlineOffset = -1.0f;
5092 Animation animation = Animation::New(1.0f);
5093 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
5094 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5095 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5096 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5097 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5098 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5099 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5100 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5101 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5104 application.SendNotification();
5105 application.Render();
5106 application.Render(1001u); // End of animation
5108 Property::Map resultMap;
5109 colorVisual.CreatePropertyMap(resultMap);
5111 // Test property values: they should be updated
5112 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5113 DALI_TEST_CHECK(colorValue);
5114 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5116 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5117 Dali::Property::Map* transformMap = transformValue->GetMap();
5118 DALI_TEST_CHECK(transformMap);
5120 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5121 DALI_TEST_CHECK(offsetValue);
5122 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5124 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5125 DALI_TEST_CHECK(sizeValue);
5126 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5128 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5129 DALI_TEST_CHECK(cornerRadiusValue);
5130 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5132 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5133 DALI_TEST_CHECK(blurRadiusValue);
5134 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5136 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5137 DALI_TEST_CHECK(borderlineWidthValue);
5138 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5140 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5141 DALI_TEST_CHECK(borderlineColorValue);
5142 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5144 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5145 DALI_TEST_CHECK(borderlineOffsetValue);
5146 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5148 // Test uniform values
5149 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5150 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5151 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5152 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5153 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5154 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5155 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5156 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5158 // Test unregistered visual
5159 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5160 DALI_TEST_CHECK(!property3.object);
5161 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5166 int UtcDaliVisualGetVisualProperty02(void)
5168 ToolkitTestApplication application;
5169 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5171 static std::vector<UniformData> customUniforms =
5173 UniformData("mixColor", Property::Type::VECTOR3),
5174 UniformData("offset", Property::Type::VECTOR2),
5175 UniformData("size", Property::Type::VECTOR2),
5176 UniformData("cornerRadius", Property::Type::VECTOR4),
5177 UniformData("borderlineWidth", Property::Type::FLOAT),
5178 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5179 UniformData("borderlineOffset", Property::Type::FLOAT),
5180 UniformData("blurRadius", Property::Type::FLOAT),
5183 TestGraphicsController& graphics = application.GetGraphicsController();
5184 graphics.AddCustomUniforms(customUniforms);
5186 VisualFactory factory = VisualFactory::Get();
5187 Property::Map propertyMap;
5188 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5189 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5191 DummyControl dummyControl = DummyControl::New(true);
5192 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5193 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5194 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5195 application.GetScene().Add(dummyControl);
5197 application.SendNotification();
5198 application.Render();
5200 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5201 Vector2 targetOffset(0.05f, 0.05f);
5202 Vector2 targetSize(1.1f, 1.1f);
5203 float targetOpacity = 0.5f;
5204 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5205 float targetBorderlineWidth = 77.7f;
5206 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5207 float targetBorderlineOffset = 1.0f;
5208 float targetBlurRadius = 10.0f;
5210 // Should work when the properties are not set before
5211 Animation animation = Animation::New(1.0f);
5212 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5213 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5214 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5215 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5216 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5217 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5218 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5219 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5220 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5223 application.SendNotification();
5224 application.Render();
5225 application.Render(1001u); // End of animation
5227 Property::Map resultMap;
5228 colorVisual.CreatePropertyMap(resultMap);
5230 // Test property values: they should be updated
5231 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5232 DALI_TEST_CHECK(colorValue);
5233 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5235 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5236 Dali::Property::Map* transformMap = transformValue->GetMap();
5237 DALI_TEST_CHECK(transformMap);
5239 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5240 DALI_TEST_CHECK(offsetValue);
5241 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5243 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5244 DALI_TEST_CHECK(sizeValue);
5245 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5247 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5248 DALI_TEST_CHECK(cornerRadiusValue);
5249 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5251 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5252 DALI_TEST_CHECK(borderlineWidthValue);
5253 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5255 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5256 DALI_TEST_CHECK(borderlineColorValue);
5257 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5259 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5260 DALI_TEST_CHECK(borderlineOffsetValue);
5261 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5263 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5264 DALI_TEST_CHECK(blurRadiusValue);
5265 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5267 // Test uniform values
5268 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5269 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5270 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5271 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5272 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5277 int UtcDaliVisualGetVisualProperty03(void)
5279 ToolkitTestApplication application;
5280 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5282 static std::vector<UniformData> customUniforms =
5284 UniformData("pixelArea", Property::Type::VECTOR4),
5285 UniformData("cornerRadius", Property::Type::VECTOR4),
5286 UniformData("borderlineWidth", Property::Type::FLOAT),
5287 UniformData("borderlineColor", Property::Type::VECTOR4),
5288 UniformData("borderlineOffset", Property::Type::FLOAT),
5291 TestGraphicsController& graphics = application.GetGraphicsController();
5292 graphics.AddCustomUniforms(customUniforms);
5294 VisualFactory factory = VisualFactory::Get();
5295 Property::Map propertyMap;
5296 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5297 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5299 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5301 DummyControl dummyControl = DummyControl::New(true);
5302 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5303 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5304 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5305 application.GetScene().Add(dummyControl);
5307 // Wait for image loading
5308 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5310 application.SendNotification();
5311 application.Render();
5313 float targetOpacity = 0.5f;
5314 Vector4 targetPixelArea(0.0f, 1.0f, 2.0f, -0.5f);
5315 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5316 float targetBorderlineWidth = 10.0f;
5317 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5318 float targetBorderlineOffset = -1.5f;
5320 Animation animation = Animation::New(1.0f);
5321 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5322 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, ImageVisual::Property::PIXEL_AREA), targetPixelArea);
5323 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5324 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5325 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5326 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5329 application.SendNotification();
5330 application.Render();
5331 application.Render(1001u); // End of animation
5333 Property::Map resultMap;
5334 imageVisual.CreatePropertyMap(resultMap);
5336 // Test property values: they should be updated
5337 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5338 DALI_TEST_CHECK(colorValue);
5339 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5341 Property::Value* pixelAreaValue = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
5342 DALI_TEST_CHECK(pixelAreaValue);
5343 DALI_TEST_EQUALS(pixelAreaValue->Get<Vector4>(), targetPixelArea, TEST_LOCATION);
5345 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5346 DALI_TEST_CHECK(cornerRadiusValue);
5347 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5349 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5350 DALI_TEST_CHECK(borderlineWidthValue);
5351 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5353 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5354 DALI_TEST_CHECK(borderlineColorValue);
5355 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5357 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5358 DALI_TEST_CHECK(borderlineOffsetValue);
5359 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5361 // Test uniform value
5362 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", targetPixelArea), true, TEST_LOCATION);
5363 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5364 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5365 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5366 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5368 // Test non-animatable index, for coverage.
5369 DALI_TEST_EQUALS(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, ImageVisual::Property::URL).propertyIndex, Property::INVALID_INDEX, TEST_LOCATION);
5374 int UtcDaliVisualGetVisualProperty04(void)
5376 ToolkitTestApplication application;
5377 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5379 static std::vector<UniformData> customUniforms =
5381 UniformData("cornerRadius", Property::Type::VECTOR4),
5384 TestGraphicsController& graphics = application.GetGraphicsController();
5385 graphics.AddCustomUniforms(customUniforms);
5387 Vector2 start(-1.f, -1.f);
5388 Vector2 end(1.f, 1.f);
5389 Property::Array stopColors;
5390 stopColors.PushBack(Color::RED);
5391 stopColors.PushBack(Color::GREEN);
5393 VisualFactory factory = VisualFactory::Get();
5394 Property::Map propertyMap;
5395 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5396 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5397 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5398 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5399 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5400 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5401 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5403 DummyControl dummyControl = DummyControl::New(true);
5404 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5405 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5406 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5407 application.GetScene().Add(dummyControl);
5409 application.SendNotification();
5410 application.Render();
5412 float targetOpacity = 0.5f;
5413 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5415 Animation animation = Animation::New(1.0f);
5416 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5417 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5420 application.SendNotification();
5421 application.Render();
5422 application.Render(1001u); // End of animation
5424 Property::Map resultMap;
5425 gradientVisual.CreatePropertyMap(resultMap);
5427 // Test property values: they should be updated
5428 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5429 DALI_TEST_CHECK(colorValue);
5430 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5432 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5433 DALI_TEST_CHECK(cornerRadiusValue);
5434 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5436 // Test uniform value
5437 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5442 int UtcDaliVisualGetVisualProperty05(void)
5444 ToolkitTestApplication application;
5445 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5447 static std::vector<UniformData> customUniforms =
5449 UniformData("cornerRadius", Property::Type::VECTOR4),
5450 UniformData("borderlineWidth", Property::Type::FLOAT),
5451 UniformData("borderlineColor", Property::Type::VECTOR4),
5452 UniformData("borderlineOffset", Property::Type::FLOAT),
5455 TestGraphicsController& graphics = application.GetGraphicsController();
5456 graphics.AddCustomUniforms(customUniforms);
5458 VisualFactory factory = VisualFactory::Get();
5459 Property::Map propertyMap;
5460 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5461 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5463 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5465 DummyControl dummyControl = DummyControl::New(true);
5466 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5467 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5468 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5469 application.GetScene().Add(dummyControl);
5471 application.SendNotification();
5472 application.Render();
5474 // Wait for loading & rasterization
5475 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5477 application.SendNotification();
5478 application.Render();
5480 float targetOpacity = 0.5f;
5481 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5482 float targetBorderlineWidth = 10.0f;
5483 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5484 float targetBorderlineOffset = -1.5f;
5486 Animation animation = Animation::New(1.0f);
5487 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5488 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5489 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5490 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5491 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5494 application.SendNotification();
5495 application.Render();
5496 application.Render(1001u); // End of animation
5498 Property::Map resultMap;
5499 svgVisual.CreatePropertyMap(resultMap);
5501 // Test property values: they should be updated
5502 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5503 DALI_TEST_CHECK(colorValue);
5504 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5506 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5507 DALI_TEST_CHECK(cornerRadiusValue);
5508 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5510 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5511 DALI_TEST_CHECK(borderlineWidthValue);
5512 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5514 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5515 DALI_TEST_CHECK(borderlineColorValue);
5516 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5518 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5519 DALI_TEST_CHECK(borderlineOffsetValue);
5520 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5522 // Currently test with multiple program doesn't work well. will fix another day
5523 // Test uniform value
5524 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5525 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5526 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5527 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5532 int UtcDaliVisualGetVisualProperty06(void)
5534 ToolkitTestApplication application;
5535 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5537 static std::vector<UniformData> customUniforms =
5539 UniformData("cornerRadius", Property::Type::VECTOR4),
5540 UniformData("borderlineWidth", Property::Type::FLOAT),
5541 UniformData("borderlineColor", Property::Type::VECTOR4),
5542 UniformData("borderlineOffset", Property::Type::FLOAT),
5545 TestGraphicsController& graphics = application.GetGraphicsController();
5546 graphics.AddCustomUniforms(customUniforms);
5548 VisualFactory factory = VisualFactory::Get();
5549 Property::Map propertyMap;
5550 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5551 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5553 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5555 DummyControl dummyControl = DummyControl::New(true);
5556 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5557 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5558 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5559 application.GetScene().Add(dummyControl);
5561 application.SendNotification();
5562 application.Render();
5564 // Wait for image loading
5565 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5567 application.SendNotification();
5568 application.Render();
5570 float targetOpacity = 0.5f;
5571 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5572 float targetBorderlineWidth = 10.0f;
5573 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5574 float targetBorderlineOffset = -1.5f;
5576 Animation animation = Animation::New(1.0f);
5577 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5578 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5579 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5580 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5581 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5584 application.SendNotification();
5585 application.Render();
5586 application.Render(1001u); // End of animation
5588 Property::Map resultMap;
5589 animatedImageVisual.CreatePropertyMap(resultMap);
5591 // Test property values: they should be updated
5592 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5593 DALI_TEST_CHECK(colorValue);
5594 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5596 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5597 DALI_TEST_CHECK(cornerRadiusValue);
5598 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5600 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5601 DALI_TEST_CHECK(borderlineWidthValue);
5602 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5604 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5605 DALI_TEST_CHECK(borderlineColorValue);
5606 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5608 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5609 DALI_TEST_CHECK(borderlineOffsetValue);
5610 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5612 // Currently test with multiple program doesn't work well. will fix another day
5613 // Test uniform value
5614 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5615 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5616 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5617 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5622 int UtcDaliVisualGetVisualProperty07(void)
5624 ToolkitTestApplication application;
5625 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5627 static std::vector<UniformData> customUniforms =
5629 UniformData("cornerRadius", Property::Type::VECTOR4),
5630 UniformData("borderlineWidth", Property::Type::FLOAT),
5631 UniformData("borderlineColor", Property::Type::VECTOR4),
5632 UniformData("borderlineOffset", Property::Type::FLOAT),
5635 TestGraphicsController& graphics = application.GetGraphicsController();
5636 graphics.AddCustomUniforms(customUniforms);
5638 VisualFactory factory = VisualFactory::Get();
5639 Property::Map propertyMap;
5640 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5641 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5642 propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, false);
5644 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5646 DummyControl dummyControl = DummyControl::New(true);
5647 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5648 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5649 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5650 application.GetScene().Add(dummyControl);
5652 application.SendNotification();
5653 application.Render();
5655 // Trigger count is 2 - load & render a frame
5656 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5658 application.SendNotification();
5659 application.Render();
5661 float targetOpacity = 0.5f;
5662 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5663 float targetBorderlineWidth = 10.0f;
5664 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5665 float targetBorderlineOffset = -1.5f;
5667 Animation animation = Animation::New(1.0f);
5668 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5669 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5670 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5671 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5672 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5675 application.SendNotification();
5676 application.Render();
5677 application.Render(1001u); // End of animation
5679 Property::Map resultMap;
5680 animatedVectorVisual.CreatePropertyMap(resultMap);
5682 // Test property values: they should be updated
5683 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5684 DALI_TEST_CHECK(colorValue);
5685 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5687 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5688 DALI_TEST_CHECK(cornerRadiusValue);
5689 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5691 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5692 DALI_TEST_CHECK(borderlineWidthValue);
5693 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5695 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5696 DALI_TEST_CHECK(borderlineColorValue);
5697 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5699 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5700 DALI_TEST_CHECK(borderlineOffsetValue);
5701 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5703 // Currently test with multiple program doesn't work well. will fix another day
5704 // Test uniform value
5705 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5706 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5707 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5708 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5713 int UtcDaliVisualUpdateProperty01(void)
5715 ToolkitTestApplication application;
5716 tet_infoline("UtcDaliVisualUpdateProperty01: Test update property by DoAction. Standard case");
5718 VisualFactory factory = VisualFactory::Get();
5719 Property::Map propertyMap;
5720 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5721 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5722 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5723 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5725 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5727 DummyControl dummyControl = DummyControl::New(true);
5728 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5729 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5730 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5731 application.GetScene().Add(dummyControl);
5733 application.SendNotification();
5734 application.Render();
5736 // Wait for image loading
5737 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5739 application.SendNotification();
5740 application.Render();
5742 Property::Map originalMap;
5743 imageVisual.CreatePropertyMap(originalMap);
5745 float targetOpacity = 0.5f;
5746 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5747 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5748 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5749 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5750 float targetBorderlineWidth = 20.0f;
5751 Vector4 targetBorderlineColor = Color::RED;
5752 float targetBorderlineOffset = 1.0f;
5754 Property::Map targetPropertyMap;
5755 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5756 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5757 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5758 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5759 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5760 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5761 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5762 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5763 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5765 // Update Properties
5766 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5768 Property::Map resultMap;
5769 imageVisual.CreatePropertyMap(resultMap);
5771 // Test property values: they should be updated
5772 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5773 DALI_TEST_CHECK(colorValue);
5774 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5776 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5777 DALI_TEST_CHECK(urlValue);
5778 // NOTE : ImageVisual URL must NOT changed.
5779 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5781 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5782 DALI_TEST_CHECK(preMultipliedValue);
5783 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5785 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5786 DALI_TEST_CHECK(visualFittingModeValue);
5787 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5789 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5790 DALI_TEST_CHECK(cornerRadiusValue);
5791 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5793 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5794 DALI_TEST_CHECK(borderlineWidthValue);
5795 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5797 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5798 DALI_TEST_CHECK(borderlineColorValue);
5799 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5801 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5802 DALI_TEST_CHECK(borderlineOffsetValue);
5803 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5808 int UtcDaliVisualUpdateProperty02(void)
5810 ToolkitTestApplication application;
5811 tet_infoline("UtcDaliVisualUpdateProperty02: Test update property by DoAction. Initialize as zero, and update non-zero case");
5813 Vector4 borderlineColor = Color::BLUE;
5814 float borderlineOffset = 1.0f;
5816 VisualFactory factory = VisualFactory::Get();
5817 Property::Map propertyMap;
5818 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5819 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5820 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5821 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5822 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 0.0f;
5823 propertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5824 propertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5825 propertyMap[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
5826 propertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
5828 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5830 DummyControl dummyControl = DummyControl::New(true);
5831 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5832 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5833 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5834 application.GetScene().Add(dummyControl);
5836 application.SendNotification();
5837 application.Render();
5839 // Wait for image loading
5840 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5842 application.SendNotification();
5843 application.Render();
5845 Property::Map originalMap;
5846 imageVisual.CreatePropertyMap(originalMap);
5848 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5849 float targetBorderlineWidth = 20.0f;
5851 Property::Map targetPropertyMap;
5852 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5853 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5855 // Update Properties
5856 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5858 Property::Map resultMap;
5859 imageVisual.CreatePropertyMap(resultMap);
5861 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5862 DALI_TEST_CHECK(cornerRadiusValue);
5863 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5865 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5866 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5867 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5869 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5870 DALI_TEST_CHECK(borderlineWidthValue);
5871 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5873 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5874 DALI_TEST_CHECK(borderlineColorValue);
5875 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), borderlineColor, TEST_LOCATION);
5877 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5878 DALI_TEST_CHECK(borderlineOffsetValue);
5879 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), borderlineOffset, TEST_LOCATION);
5884 int UtcDaliVisualUpdatePropertyInvalidType(void)
5886 ToolkitTestApplication application;
5887 tet_infoline("UtcDaliVisualUpdatePropertyInvalidType: Test update property by DoAction. But some value is not invalid to update");
5889 VisualFactory factory = VisualFactory::Get();
5890 Property::Map propertyMap;
5891 propertyMap[Visual::Property::TYPE] = Visual::Type::N_PATCH;
5892 propertyMap[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
5894 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5896 DummyControl dummyControl = DummyControl::New(true);
5897 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5898 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5899 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5900 application.GetScene().Add(dummyControl);
5902 application.SendNotification();
5903 application.Render();
5905 // Wait for image loading
5906 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5908 application.SendNotification();
5909 application.Render();
5911 Property::Map originalMap;
5912 imageVisual.CreatePropertyMap(originalMap);
5914 float targetOpacity = 0.5f;
5915 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5916 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5917 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5918 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5919 float targetBorderlineWidth = 20.0f;
5920 Vector4 targetBorderlineColor = Color::RED;
5921 float targetBorderlineOffset = 1.0f;
5923 Property::Map targetPropertyMap;
5924 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5925 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5926 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5927 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5928 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5930 // Properties that N_PATCH visual could not used.
5931 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5932 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5933 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5934 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5936 // Update Properties
5937 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5939 Property::Map resultMap;
5940 imageVisual.CreatePropertyMap(resultMap);
5942 // Test property values: they should be updated
5943 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5944 DALI_TEST_CHECK(colorValue);
5945 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5947 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5948 DALI_TEST_CHECK(urlValue);
5949 // NOTE : NPatchVisual URL must NOT changed.
5950 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_NPATCH_FILE_NAME, TEST_LOCATION);
5952 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5953 DALI_TEST_CHECK(preMultipliedValue);
5954 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5956 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5957 DALI_TEST_CHECK(visualFittingModeValue);
5958 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5960 // We don't check properties value that N_PATCH visual could not used.
5966 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5968 ToolkitTestApplication application;
5969 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5971 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5973 VisualFactory factory = VisualFactory::Get();
5974 Property::Map propertyMap;
5976 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5977 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5979 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5981 DummyControl dummyControl = DummyControl::New(true);
5982 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5983 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5984 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5985 application.GetScene().Add(dummyControl);
5987 application.SendNotification();
5988 application.Render();
5990 // Wait for image loading
5991 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5993 application.SendNotification();
5994 application.Render();
5996 TestShaderCodeContainSubstrings(
5999 {"#define IS_REQUIRED_BORDERLINE", false},
6000 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6005 callStack.Enable(true);
6007 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
6009 Property::Map targetPropertyMap;
6010 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6011 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
6013 // Update Properties with CornerRadius
6014 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6016 Property::Map resultMap;
6017 imageVisual.CreatePropertyMap(resultMap);
6019 // Test property values: they should be updated
6020 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6021 DALI_TEST_CHECK(cornerRadiusValue);
6022 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6024 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6025 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6026 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
6028 TestShaderCodeContainSubstrings(
6031 {"#define IS_REQUIRED_BORDERLINE", false},
6032 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6036 // Send shader compile signal
6037 application.SendNotification();
6038 application.Render();
6040 callStack.Enable(false);
6042 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6044 callStack.Enable(true);
6046 float targetBorderlineWidth = 10.0f;
6047 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
6048 float targetBorderlineOffset = -0.3f;
6050 Property::Map targetPropertyMap2;
6051 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6052 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6053 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6054 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6055 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6057 // Update Properties with Borderline
6058 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6060 Property::Map resultMap2;
6061 imageVisual.CreatePropertyMap(resultMap2);
6063 // Test property values: they should be updated
6064 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6065 DALI_TEST_CHECK(cornerRadiusValue);
6066 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6068 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6069 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6070 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6072 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6073 DALI_TEST_CHECK(borderlineWidthValue);
6074 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6076 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6077 DALI_TEST_CHECK(borderlineColorValue);
6078 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6080 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6081 DALI_TEST_CHECK(borderlineOffsetValue);
6082 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6084 TestShaderCodeContainSubstrings(
6087 {"#define IS_REQUIRED_BORDERLINE", true},
6088 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6092 // Send shader compile signal
6093 application.SendNotification();
6094 application.Render();
6096 callStack.Enable(false);
6098 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6100 callStack.Enable(true);
6102 Property::Map targetPropertyMap3;
6103 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6104 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6105 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
6106 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
6107 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
6109 // Update Properties into zero
6110 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
6112 Property::Map resultMap3;
6113 imageVisual.CreatePropertyMap(resultMap3);
6115 // Test property values: they should be updated
6116 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6117 DALI_TEST_CHECK(cornerRadiusValue);
6118 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6120 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6121 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6122 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6124 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6125 DALI_TEST_CHECK(borderlineWidthValue);
6126 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
6128 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6129 DALI_TEST_CHECK(borderlineColorValue);
6130 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6132 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6133 DALI_TEST_CHECK(borderlineOffsetValue);
6134 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
6136 TestShaderCodeContainSubstrings(
6139 {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
6140 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6144 // Send shader compile signal
6145 application.SendNotification();
6146 application.Render();
6148 callStack.Enable(false);
6149 // Shader not changed
6150 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6155 int UtcDaliVisualUpdatePropertyChangeShader02(void)
6157 ToolkitTestApplication application;
6158 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
6160 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6162 VisualFactory factory = VisualFactory::Get();
6163 Property::Map propertyMap;
6165 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6166 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6168 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6170 DummyControl dummyControl = DummyControl::New(true);
6171 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6172 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6173 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6174 application.GetScene().Add(dummyControl);
6176 application.SendNotification();
6177 application.Render();
6179 // Wait for image loading
6180 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6182 application.SendNotification();
6183 application.Render();
6185 TestShaderCodeContainSubstrings(
6188 {"#define IS_REQUIRED_BORDERLINE", false},
6189 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6193 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6195 Property::Map targetPropertyMap;
6196 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6199 callStack.Enable(true);
6201 // Update Properties with CornerRadius
6202 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6204 Property::Map resultMap;
6205 imageVisual.CreatePropertyMap(resultMap);
6207 // Test property values: they should be updated
6208 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6209 DALI_TEST_CHECK(cornerRadiusValue);
6210 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6212 TestShaderCodeContainSubstrings(
6215 {"#define IS_REQUIRED_BORDERLINE", false},
6216 {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
6220 // Send shader compile signal
6221 application.SendNotification();
6222 application.Render();
6224 callStack.Enable(false);
6226 // Shader doesn't changed
6227 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6229 callStack.Enable(true);
6231 float targetBorderlineWidth = 0.0f;
6232 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
6233 float targetBorderlineOffset = -1.0f;
6235 Property::Map targetPropertyMap2;
6236 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6237 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6238 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6240 // Update Properties with Borderline
6241 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6243 Property::Map resultMap2;
6244 imageVisual.CreatePropertyMap(resultMap2);
6246 // Test property values: they should be updated
6247 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6248 DALI_TEST_CHECK(borderlineWidthValue);
6249 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6251 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6252 DALI_TEST_CHECK(borderlineColorValue);
6253 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6255 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6256 DALI_TEST_CHECK(borderlineOffsetValue);
6257 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6259 TestShaderCodeContainSubstrings(
6262 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
6263 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6267 // Send shader compile signal
6268 application.SendNotification();
6269 application.Render();
6271 callStack.Enable(false);
6273 // Shader doesn't changed
6274 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6279 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6281 ToolkitTestApplication application;
6282 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6284 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6286 VisualFactory factory = VisualFactory::Get();
6287 Property::Map propertyMap;
6289 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6290 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6292 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6294 DummyControl dummyControl = DummyControl::New(true);
6295 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6296 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6297 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6298 application.GetScene().Add(dummyControl);
6300 application.SendNotification();
6301 application.Render();
6303 application.SendNotification();
6304 application.Render();
6306 TestShaderCodeContainSubstrings(
6309 {"#define IS_REQUIRED_BLUR", false},
6310 {"#define IS_REQUIRED_BORDERLINE", false},
6311 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6315 float targetBlurRadius = 15.0f;
6316 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6318 Property::Map targetPropertyMap;
6319 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6320 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6321 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6324 callStack.Enable(true);
6326 // Update Properties with CornerRadius
6327 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6329 Property::Map resultMap;
6330 imageVisual.CreatePropertyMap(resultMap);
6332 // Test property values: they should be updated
6333 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6334 DALI_TEST_CHECK(blurRadiusValue);
6335 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6337 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6338 DALI_TEST_CHECK(cornerRadiusValue);
6339 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6341 TestShaderCodeContainSubstrings(
6344 {"#define IS_REQUIRED_BLUR", true},
6345 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6346 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6350 // Send shader compile signal
6351 application.SendNotification();
6352 application.Render();
6354 callStack.Enable(false);
6357 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6359 callStack.Enable(true);
6361 Property::Map targetPropertyMap2;
6362 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6363 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6364 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6366 // Update Properties with CornerRadius
6367 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6369 Property::Map resultMap2;
6370 imageVisual.CreatePropertyMap(resultMap2);
6372 // Test property values: they should be updated
6373 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6374 DALI_TEST_CHECK(blurRadiusValue);
6375 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6377 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6378 DALI_TEST_CHECK(cornerRadiusValue);
6379 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6381 TestShaderCodeContainSubstrings(
6384 {"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
6385 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6386 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6390 // Send shader compile signal
6391 application.SendNotification();
6392 application.Render();
6394 callStack.Enable(false);
6396 // Shader not changed
6397 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6402 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6404 ToolkitTestApplication application;
6405 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6407 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6409 VisualFactory factory = VisualFactory::Get();
6410 Property::Map propertyMap;
6412 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6413 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6414 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6416 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6418 DummyControl dummyControl = DummyControl::New(true);
6419 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6420 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6421 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6422 application.GetScene().Add(dummyControl);
6424 application.SendNotification();
6425 application.Render();
6427 // Wait for image loading
6428 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6430 application.SendNotification();
6431 application.Render();
6433 TestShaderCodeContainSubstrings(
6436 {"#define IS_REQUIRED_BORDERLINE", false},
6437 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6442 callStack.Enable(true);
6444 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6446 Animation animation = Animation::New(1.0f);
6447 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6450 application.SendNotification();
6451 application.Render();
6452 application.Render(1001u); // End of animation
6454 TestShaderCodeContainSubstrings(
6457 {"#define IS_REQUIRED_BORDERLINE", false},
6458 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6462 callStack.Enable(false);
6463 // Shader not changed
6464 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6466 callStack.Enable(true);
6468 float targetBorderlineWidth = 10.0f;
6469 Property::Map targetPropertyMap;
6470 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6472 // Update Properties with CornerRadius
6473 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6475 Property::Map resultMap;
6476 imageVisual.CreatePropertyMap(resultMap);
6478 // Test property values: they should be updated
6479 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6480 DALI_TEST_CHECK(cornerRadiusValue);
6481 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6483 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6484 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6485 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6487 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6488 DALI_TEST_CHECK(borderlineWidthValue);
6489 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6491 TestShaderCodeContainSubstrings(
6494 {"#define IS_REQUIRED_BORDERLINE", true},
6495 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6499 // Send shader compile signal
6500 application.SendNotification();
6501 application.Render();
6503 callStack.Enable(false);
6505 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6510 int UtcDaliVisualUpdatePropertyChangeShader05(void)
6512 ToolkitTestApplication application;
6513 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader05: Test update property under glsl version is under 300");
6515 auto originalShaderVersion = application.GetGlAbstraction().GetShaderLanguageVersion();
6517 // Change the shader language version forcely!
6518 application.GetGlAbstraction().mShaderLanguageVersion = 200;
6522 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6524 VisualFactory factory = VisualFactory::Get();
6525 Property::Map propertyMap;
6527 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6528 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6530 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6532 DummyControl dummyControl = DummyControl::New(true);
6533 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6534 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6535 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6536 application.GetScene().Add(dummyControl);
6538 application.SendNotification();
6539 application.Render();
6541 application.SendNotification();
6542 application.Render();
6544 TestShaderCodeContainSubstrings(
6547 {"#define IS_REQUIRED_BLUR", false},
6548 {"#define IS_REQUIRED_BORDERLINE", false},
6549 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6553 float targetBlurRadius = 15.0f;
6554 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6556 Property::Map targetPropertyMap;
6557 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6558 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6559 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6562 callStack.Enable(true);
6564 // Update Properties with CornerRadius
6565 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6567 Property::Map resultMap;
6568 imageVisual.CreatePropertyMap(resultMap);
6570 // Test property values: they should be updated
6571 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6572 DALI_TEST_CHECK(blurRadiusValue);
6573 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6575 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6576 DALI_TEST_CHECK(cornerRadiusValue);
6577 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6579 TestShaderCodeContainSubstringsForEachShader(
6582 {"#define IS_REQUIRED_BLUR", {true, true}},
6583 {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
6584 {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}},
6585 {"#define SL_VERSION_LOW", {false, true}},
6589 // Send shader compile signal
6590 application.SendNotification();
6591 application.Render();
6593 callStack.Enable(false);
6596 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6598 callStack.Enable(true);
6600 Property::Map targetPropertyMap2;
6601 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6602 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6603 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6605 // Update Properties with CornerRadius
6606 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6608 Property::Map resultMap2;
6609 imageVisual.CreatePropertyMap(resultMap2);
6611 // Test property values: they should be updated
6612 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6613 DALI_TEST_CHECK(blurRadiusValue);
6614 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6616 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6617 DALI_TEST_CHECK(cornerRadiusValue);
6618 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6620 TestShaderCodeContainSubstringsForEachShader(
6623 {"#define IS_REQUIRED_BLUR", {true, true}}, // Note : mAlwaysUsingBlurRadius is true.
6624 {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
6625 {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}}, // Note : mAlwaysUsingCornerRadius is true.
6626 {"#define SL_VERSION_LOW", {false, true}},
6630 // Send shader compile signal
6631 application.SendNotification();
6632 application.Render();
6634 callStack.Enable(false);
6636 // Shader not changed
6637 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6641 DALI_TEST_CHECK(false);
6644 // Revert shader version. We should revert it even if UTC failed.
6645 application.GetGlAbstraction().mShaderLanguageVersion = originalShaderVersion;