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 propertyMap.Insert(DevelColorVisual::Property::CUTOUT_POLICY, DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS);
559 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
561 Property::Map resultMap;
562 colorVisual.CreatePropertyMap(resultMap);
564 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
565 DALI_TEST_CHECK(typeValue);
566 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
568 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
569 DALI_TEST_CHECK(colorValue);
570 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
572 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
573 DALI_TEST_CHECK(cornerRadiusValue);
574 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
576 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
577 DALI_TEST_CHECK(cornerRadiusPolicyValue);
578 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
580 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
581 DALI_TEST_CHECK(borderlineWidthValue);
582 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
584 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
585 DALI_TEST_CHECK(borderlineColorValue);
586 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
588 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
589 DALI_TEST_CHECK(borderlineOffsetValue);
590 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
592 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
593 DALI_TEST_CHECK(blurRadiusValue);
594 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
596 Property::Value* cutoutPolicyValue = resultMap.Find(DevelColorVisual::Property::CUTOUT_POLICY, Property::INTEGER);
597 DALI_TEST_CHECK(cutoutPolicyValue);
598 DALI_TEST_CHECK(cutoutPolicyValue->Get<int>() == DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS);
600 // change the blend color
601 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
602 colorVisual = factory.CreateVisual(propertyMap);
603 colorVisual.CreatePropertyMap(resultMap);
605 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
606 DALI_TEST_CHECK(colorValue);
607 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
610 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
612 colorVisual = factory.CreateVisual(propertyMap);
613 colorVisual.CreatePropertyMap(resultMap);
615 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
616 DALI_TEST_CHECK(blurRadiusValue);
617 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
619 // Test wrong values 2
620 propertyMap[DevelColorVisual::Property::CUTOUT_POLICY] = Vector2(2.0f, 3.0f);
622 colorVisual = factory.CreateVisual(propertyMap);
623 colorVisual.CreatePropertyMap(resultMap);
625 cutoutPolicyValue = resultMap.Find(DevelColorVisual::Property::CUTOUT_POLICY, Property::INTEGER);
626 DALI_TEST_CHECK(cutoutPolicyValue);
627 DALI_TEST_CHECK(cutoutPolicyValue->Get<int>() == DevelColorVisual::CutoutPolicy::NONE);
629 // Test property set by string
630 propertyMap[DevelColorVisual::Property::CUTOUT_POLICY] = "CUTOUT_VIEW";
632 colorVisual = factory.CreateVisual(propertyMap);
633 colorVisual.CreatePropertyMap(resultMap);
635 cutoutPolicyValue = resultMap.Find(DevelColorVisual::Property::CUTOUT_POLICY, Property::INTEGER);
636 DALI_TEST_CHECK(cutoutPolicyValue);
637 DALI_TEST_CHECK(cutoutPolicyValue->Get<int>() == DevelColorVisual::CutoutPolicy::CUTOUT_VIEW);
639 propertyMap[DevelColorVisual::Property::CUTOUT_POLICY] = "CUTOUT_VIEW_WITH_CORNER_RADIUS";
641 colorVisual = factory.CreateVisual(propertyMap);
642 colorVisual.CreatePropertyMap(resultMap);
644 cutoutPolicyValue = resultMap.Find(DevelColorVisual::Property::CUTOUT_POLICY, Property::INTEGER);
645 DALI_TEST_CHECK(cutoutPolicyValue);
646 DALI_TEST_CHECK(cutoutPolicyValue->Get<int>() == DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS);
651 int UtcDaliVisualGetPropertyMap2(void)
653 ToolkitTestApplication application;
654 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
656 VisualFactory factory = VisualFactory::Get();
657 Property::Map propertyMap;
658 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
659 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
660 propertyMap.Insert("borderColor", Color::BLUE);
661 propertyMap.Insert("borderSize", 5.f);
662 propertyMap.Insert("antiAliasing", true);
663 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
665 Property::Map resultMap;
666 borderVisual.CreatePropertyMap(resultMap);
668 // check the property values from the returned map from visual
669 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
670 DALI_TEST_CHECK(typeValue);
671 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
673 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
674 DALI_TEST_CHECK(colorValue);
675 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
677 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
678 DALI_TEST_CHECK(sizeValue);
679 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
681 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
682 DALI_TEST_CHECK(AAValue);
683 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
685 Property::Map propertyMap1;
686 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
687 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
688 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
689 borderVisual = factory.CreateVisual(propertyMap1);
690 borderVisual.CreatePropertyMap(resultMap);
692 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
693 DALI_TEST_CHECK(typeValue);
694 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
696 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
697 DALI_TEST_CHECK(colorValue);
698 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
700 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
701 DALI_TEST_CHECK(sizeValue);
702 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
707 int UtcDaliVisualGetPropertyMap2N(void)
709 ToolkitTestApplication application;
710 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
712 VisualFactory factory = VisualFactory::Get();
713 Property::Map propertyMap;
714 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
715 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
717 tet_infoline("Test that the visual is created, with a default renderer");
718 DALI_TEST_CHECK(borderVisual);
720 DummyControl dummyControl = DummyControl::New(true);
721 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
722 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
723 application.GetScene().Add(dummyControl);
725 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
730 int UtcDaliVisualGetPropertyMap3(void)
732 ToolkitTestApplication application;
733 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
735 VisualFactory factory = VisualFactory::Get();
736 DALI_TEST_CHECK(factory);
738 Property::Map propertyMap;
739 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
741 Vector2 start(-1.f, -1.f);
742 Vector2 end(1.f, 1.f);
743 propertyMap.Insert("startPosition", start);
744 propertyMap.Insert("endPosition", end);
745 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
747 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
749 Property::Array stopColors;
750 stopColors.PushBack(Color::RED);
751 stopColors.PushBack(Color::GREEN);
752 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
754 float borderlineWidth = 4.0f;
755 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
756 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
757 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
759 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
761 Property::Map resultMap;
762 gradientVisual.CreatePropertyMap(resultMap);
764 // check the property values from the returned map from visual
765 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
766 DALI_TEST_CHECK(value);
767 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
769 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
770 DALI_TEST_CHECK(value);
771 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
773 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
774 DALI_TEST_CHECK(value);
775 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
777 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
778 DALI_TEST_CHECK(value);
779 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
781 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
782 DALI_TEST_CHECK(value);
783 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
785 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
786 DALI_TEST_CHECK(value);
787 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
789 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
790 DALI_TEST_CHECK(value);
791 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
793 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
794 DALI_TEST_CHECK(value);
795 Property::Array* offsetArray = value->GetArray();
796 DALI_TEST_CHECK(offsetArray->Count() == 2);
797 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
798 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
800 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
801 DALI_TEST_CHECK(value);
802 Property::Array* colorArray = value->GetArray();
803 DALI_TEST_CHECK(colorArray->Count() == 2);
804 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
805 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
810 int UtcDaliVisualGetPropertyMap4(void)
812 ToolkitTestApplication application;
813 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
815 VisualFactory factory = VisualFactory::Get();
816 DALI_TEST_CHECK(factory);
818 Property::Map propertyMap;
819 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
821 Vector2 center(100.f, 100.f);
822 float radius = 100.f;
823 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
824 propertyMap.Insert(GradientVisual::Property::CENTER, center);
825 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
826 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
828 Property::Array stopColors;
829 stopColors.PushBack(Color::RED);
830 stopColors.PushBack(Color::BLACK);
831 stopColors.PushBack(Color::GREEN);
832 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
834 float borderlineWidth = 8.0f;
835 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
836 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
837 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
839 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
840 DALI_TEST_CHECK(gradientVisual);
842 Property::Map resultMap;
843 gradientVisual.CreatePropertyMap(resultMap);
845 // check the property values from the returned map from visual
846 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
847 DALI_TEST_CHECK(value);
848 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
850 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
851 DALI_TEST_CHECK(value);
852 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
854 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
855 DALI_TEST_CHECK(value);
856 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
858 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
859 DALI_TEST_CHECK(value);
860 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
862 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
863 DALI_TEST_CHECK(value);
864 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
866 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
867 DALI_TEST_CHECK(value);
868 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
870 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
871 DALI_TEST_CHECK(value);
872 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
874 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
875 DALI_TEST_CHECK(value);
876 Property::Array* offsetArray = value->GetArray();
877 DALI_TEST_CHECK(offsetArray->Count() == 3);
878 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
879 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
880 // any stop value will be clamped to [0.0, 1.0];
881 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
883 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
884 DALI_TEST_CHECK(value);
885 Property::Array* colorArray = value->GetArray();
886 DALI_TEST_CHECK(colorArray->Count() == 3);
887 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
888 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
889 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
894 int UtcDaliVisualGetPropertyMap5(void)
896 ToolkitTestApplication application;
897 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
899 VisualFactory factory = VisualFactory::Get();
900 Property::Map propertyMap;
901 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
902 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
903 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
904 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
905 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
906 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
907 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
908 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
909 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
910 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
911 propertyMap.Insert("synchronousLoading", true);
913 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
914 DALI_TEST_CHECK(imageVisual);
916 Property::Map resultMap;
917 imageVisual.CreatePropertyMap(resultMap);
919 // check the property values from the returned map from visual
920 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
921 DALI_TEST_CHECK(value);
922 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
924 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
925 DALI_TEST_CHECK(value);
926 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
928 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
929 DALI_TEST_CHECK(value);
930 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
932 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
933 DALI_TEST_CHECK(value);
934 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
936 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
937 DALI_TEST_CHECK(value);
938 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
940 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
941 DALI_TEST_CHECK(value);
942 DALI_TEST_CHECK(value->Get<int>() == 20);
944 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
945 DALI_TEST_CHECK(value);
946 DALI_TEST_CHECK(value->Get<int>() == 30);
948 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
949 DALI_TEST_CHECK(value);
950 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
952 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
953 DALI_TEST_CHECK(value);
954 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
956 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
957 DALI_TEST_CHECK(value);
958 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
960 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
961 DALI_TEST_CHECK(value);
962 DALI_TEST_CHECK(value->Get<bool>() == true);
967 int UtcDaliVisualGetPropertyMap6(void)
969 ToolkitTestApplication application;
970 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
972 Rect<int> border(1, 1, 1, 1);
974 VisualFactory factory = VisualFactory::Get();
975 Property::Map propertyMap;
976 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
977 propertyMap.Insert("mixColor", Color::MAGENTA);
978 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
979 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
980 propertyMap.Insert(ImageVisual::Property::BORDER, border);
981 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
982 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
983 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
985 Property::Map resultMap;
986 nPatchVisual.CreatePropertyMap(resultMap);
988 // check the property values from the returned map from visual
989 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
990 DALI_TEST_CHECK(value);
991 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
993 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
994 DALI_TEST_CHECK(value);
995 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
997 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
998 DALI_TEST_CHECK(value);
999 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
1001 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
1002 DALI_TEST_CHECK(value);
1003 DALI_TEST_CHECK(value->Get<bool>());
1005 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
1006 DALI_TEST_CHECK(value);
1007 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
1009 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
1010 DALI_TEST_CHECK(value);
1011 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
1013 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
1014 DALI_TEST_CHECK(value);
1015 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
1017 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
1019 Property::Map propertyMap1;
1020 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
1021 propertyMap1.Insert("mixColor", Color::MAGENTA);
1022 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
1023 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
1024 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
1025 nPatchVisual = factory.CreateVisual(propertyMap1);
1027 nPatchVisual.CreatePropertyMap(resultMap);
1029 // check the property values from the returned map from visual
1030 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1031 DALI_TEST_CHECK(value);
1032 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
1034 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1035 DALI_TEST_CHECK(value);
1036 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
1038 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1039 DALI_TEST_CHECK(value);
1040 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
1042 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
1043 DALI_TEST_CHECK(value);
1044 DALI_TEST_CHECK(value->Get<bool>());
1046 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
1047 DALI_TEST_CHECK(value);
1048 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
1053 int UtcDaliVisualGetPropertyMap7(void)
1055 ToolkitTestApplication application;
1056 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
1058 // request SvgVisual with a property map
1059 VisualFactory factory = VisualFactory::Get();
1060 Property::Map propertyMap;
1061 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
1062 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
1063 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
1064 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
1065 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
1067 Property::Map resultMap;
1068 svgVisual.CreatePropertyMap(resultMap);
1069 // check the property values from the returned map from a visual
1070 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1071 DALI_TEST_CHECK(value);
1072 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1074 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1075 DALI_TEST_CHECK(value);
1076 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1078 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1079 DALI_TEST_CHECK(value);
1080 DALI_TEST_CHECK(value->Get<bool>() == false);
1082 // request SvgVisual with a property map 2
1083 propertyMap.Clear();
1084 propertyMap["visualType"] = Visual::SVG;
1085 propertyMap["mixColor"] = Color::WHITE;
1086 propertyMap["url"] = TEST_SVG_FILE_NAME;
1087 propertyMap["atlasing"] = true;
1088 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1091 svgVisual1.CreatePropertyMap(resultMap);
1092 // check the property values from the returned map from a visual
1093 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1094 DALI_TEST_CHECK(value);
1095 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1097 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1098 DALI_TEST_CHECK(value);
1099 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1101 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1102 DALI_TEST_CHECK(value);
1103 DALI_TEST_CHECK(value->Get<bool>() == true);
1105 // request SvgVisual with an URL
1106 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1108 svgVisual2.CreatePropertyMap(resultMap);
1109 // check the property values from the returned map from a visual
1110 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1111 DALI_TEST_CHECK(value);
1112 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1114 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1115 DALI_TEST_CHECK(value);
1116 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1122 int UtcDaliVisualGetPropertyMap8(void)
1124 ToolkitTestApplication application;
1125 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1127 //Request MeshVisual using a property map.
1128 VisualFactory factory = VisualFactory::Get();
1129 Property::Map propertyMap;
1130 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1131 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1132 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1133 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1134 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1135 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1136 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1137 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1139 Property::Map resultMap;
1140 meshVisual.CreatePropertyMap(resultMap);
1141 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1143 //Check values in the result map are identical to the initial map's values.
1144 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1145 DALI_TEST_CHECK(value);
1146 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1148 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1149 DALI_TEST_CHECK(value);
1150 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1152 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1153 DALI_TEST_CHECK(value);
1154 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1156 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1157 DALI_TEST_CHECK(value);
1158 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1160 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1161 DALI_TEST_CHECK(value);
1162 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1164 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1165 DALI_TEST_CHECK(value);
1166 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1171 //Primitive shape visual
1172 int UtcDaliVisualGetPropertyMap9(void)
1174 ToolkitTestApplication application;
1175 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1177 static std::vector<UniformData> customUniforms =
1179 UniformData("mixColor", Property::Type::VECTOR3),
1182 TestGraphicsController& graphics = application.GetGraphicsController();
1183 graphics.AddCustomUniforms(customUniforms);
1185 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1186 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1188 //Request PrimitiveVisual using a property map.
1189 VisualFactory factory = VisualFactory::Get();
1190 Property::Map propertyMap;
1191 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1192 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1193 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1194 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1195 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1196 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1197 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1198 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1199 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1200 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1201 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1202 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1203 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1204 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1206 Property::Map resultMap;
1207 primitiveVisual.CreatePropertyMap(resultMap);
1209 //Check values in the result map are identical to the initial map's values.
1210 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1211 DALI_TEST_CHECK(value);
1212 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1214 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1215 DALI_TEST_CHECK(value);
1216 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1218 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1219 DALI_TEST_CHECK(value);
1220 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1221 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1223 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1224 DALI_TEST_CHECK(value);
1225 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1227 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1228 DALI_TEST_CHECK(value);
1229 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1231 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1232 DALI_TEST_CHECK(value);
1233 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1235 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1236 DALI_TEST_CHECK(value);
1237 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1239 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1240 DALI_TEST_CHECK(value);
1241 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1243 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1244 DALI_TEST_CHECK(value);
1245 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1247 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1248 DALI_TEST_CHECK(value);
1249 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1251 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1252 DALI_TEST_CHECK(value);
1253 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1255 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1256 DALI_TEST_CHECK(value);
1257 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1259 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1260 DALI_TEST_CHECK(value);
1261 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1263 DummyControl actor = DummyControl::New(true);
1264 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1265 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1266 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1267 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1268 application.GetScene().Add(actor);
1270 Animation animation = Animation::New(1.0f);
1271 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1273 application.SendNotification();
1274 application.Render(0);
1275 application.Render(1000);
1276 application.SendNotification();
1278 auto& gl = application.GetGlAbstraction();
1279 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1281 tet_infoline("Check property map after animation");
1283 primitiveVisual.CreatePropertyMap(resultMap);
1284 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1285 DALI_TEST_CHECK(value);
1286 color = value->Get<Vector4>();
1287 // Ignore alpha part
1288 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1294 int UtcDaliVisualGetPropertyMap10(void)
1296 ToolkitTestApplication application;
1297 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1299 //Request PrimitiveVisual using a property map.
1300 VisualFactory factory = VisualFactory::Get();
1302 Property::Map propertyMap;
1303 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1304 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1305 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1306 propertyMap.Insert("enableMarkup", false);
1307 propertyMap.Insert("text", "Hello world");
1308 propertyMap.Insert("fontFamily", "TizenSans");
1310 Property::Map fontStyleMapSet;
1311 fontStyleMapSet.Insert("weight", "bold");
1312 propertyMap.Insert("fontStyle", fontStyleMapSet);
1314 propertyMap.Insert("pointSize", 12.f);
1315 propertyMap.Insert("multiLine", true);
1316 propertyMap.Insert("horizontalAlignment", "CENTER");
1317 propertyMap.Insert("verticalAlignment", "CENTER");
1318 propertyMap.Insert("textColor", Color::RED);
1320 Property::Map shadowMapSet;
1321 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1323 Property::Map underlineMapSet;
1324 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));
1326 Property::Map outlineMapSet;
1327 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1329 Property::Map backgroundMapSet;
1330 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1332 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1334 Property::Map resultMap;
1335 textVisual.CreatePropertyMap(resultMap);
1337 //Check values in the result map are identical to the initial map's values.
1338 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1339 DALI_TEST_CHECK(value);
1340 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1342 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1343 DALI_TEST_CHECK(value);
1344 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1346 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1347 DALI_TEST_CHECK(value);
1348 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1350 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1351 DALI_TEST_CHECK(value);
1352 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1354 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1355 DALI_TEST_CHECK(value);
1357 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1358 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1359 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1361 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1362 DALI_TEST_CHECK(value);
1363 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1365 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1366 DALI_TEST_CHECK(value);
1367 DALI_TEST_CHECK(value->Get<bool>());
1369 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1370 DALI_TEST_CHECK(value);
1371 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1373 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1374 DALI_TEST_CHECK(value);
1375 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1377 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1378 DALI_TEST_CHECK(value);
1379 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1381 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1382 DALI_TEST_CHECK(value);
1383 DALI_TEST_CHECK(!value->Get<bool>());
1385 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1386 DALI_TEST_CHECK(value);
1388 Property::Map shadowMapGet = value->Get<Property::Map>();
1389 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1390 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1392 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1393 DALI_TEST_CHECK(value);
1395 Property::Map underlineMapGet = value->Get<Property::Map>();
1396 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1397 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1399 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1400 DALI_TEST_CHECK(value);
1402 Property::Map outlineMapGet = value->Get<Property::Map>();
1403 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1404 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1406 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1407 DALI_TEST_CHECK(value);
1409 Property::Map backgroundMapGet = value->Get<Property::Map>();
1410 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1411 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1416 int UtcDaliVisualGetPropertyMap11(void)
1418 ToolkitTestApplication application;
1419 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1421 VisualFactory factory = VisualFactory::Get();
1422 DALI_TEST_CHECK(factory);
1424 Property::Map propertyMap;
1425 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1427 Vector2 start(-0.5f, 0.5f);
1428 Vector2 end(0.5f, -0.0f);
1429 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1430 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1431 Vector2 rotate_center(0.0f, 0.4f);
1432 float rotate_amount = 1.57f;
1433 float offset = 100.f;
1435 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1436 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1437 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1439 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1440 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1441 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1442 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1443 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1444 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1445 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1447 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1448 DALI_TEST_CHECK(animatedGradientVisual);
1450 Property::Map resultMap;
1451 animatedGradientVisual.CreatePropertyMap(resultMap);
1453 // check the property values from the returned map from visual
1454 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1455 DALI_TEST_CHECK(value);
1456 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1458 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1459 DALI_TEST_CHECK(value);
1460 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1462 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1463 DALI_TEST_CHECK(value);
1464 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1466 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1467 DALI_TEST_CHECK(value);
1468 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1470 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1471 DALI_TEST_CHECK(value);
1472 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1474 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1475 DALI_TEST_CHECK(value);
1476 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1478 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1479 DALI_TEST_CHECK(value);
1480 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1482 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1483 DALI_TEST_CHECK(value);
1484 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1486 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1487 DALI_TEST_CHECK(value);
1488 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1490 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1491 DALI_TEST_CHECK(value);
1492 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1494 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1495 DALI_TEST_CHECK(value);
1496 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1501 int UtcDaliVisualGetPropertyMap12(void)
1503 ToolkitTestApplication application;
1504 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1506 // Case 1 : Set values by index
1508 tet_printf(" - Set Values by Index\n");
1509 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1510 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1511 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1513 tet_printf("test with delay [%f]\n", _delay);
1514 VisualFactory factory = VisualFactory::Get();
1515 DALI_TEST_CHECK(factory);
1517 Property::Map propertyMap;
1518 Property::Map animationMap;
1519 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1521 float duration = 1.1f;
1522 float delay = _delay;
1523 float repeat_delay = 0.4f;
1525 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1527 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1528 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1530 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1531 animationMap.Clear();
1532 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1533 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1534 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1535 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1536 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1537 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1538 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1539 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1540 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1542 return animationMap;
1545 Vector2 start1(-0.5f, 0.5f);
1546 Vector2 end1(0.5f, -0.5f);
1547 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1548 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1549 Vector2 rotate_center1(0.0f, 0.4f);
1550 float rotate_amount1 = 0.0f;
1551 float offset1 = 0.f;
1553 Vector2 start2(-0.5f, -0.5f);
1554 Vector2 end2(0.5f, 0.5f);
1555 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1556 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1557 Vector2 rotate_center2(0.0f, -0.4f);
1558 float rotate_amount2 = 6.2832f;
1559 float offset2 = 2.f;
1561 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1562 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1563 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1565 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1566 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1567 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1568 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1569 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1570 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1571 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1573 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1574 DALI_TEST_CHECK(animatedGradientVisual);
1576 Property::Map resultMap;
1577 animatedGradientVisual.CreatePropertyMap(resultMap);
1579 // check the property values from the returned map from visual
1580 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1581 DALI_TEST_CHECK(value);
1582 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1584 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1585 DALI_TEST_CHECK(value);
1586 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1588 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1589 DALI_TEST_CHECK(value);
1590 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1592 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1593 DALI_TEST_CHECK(value);
1594 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1596 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 {
1597 tet_printf("Check value at %d\n", line_num);
1598 value = resultMap.Find(index, Property::MAP);
1599 DALI_TEST_CHECK(value);
1600 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1601 Property::Map* temp_map = value->GetMap();
1602 DALI_TEST_CHECK(temp_map);
1604 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1605 Property::Value* res = temp_map->Find(index);
1606 DALI_TEST_CHECK(res);
1610 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1611 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1612 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1613 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1614 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1615 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1616 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1617 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1618 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1621 // check the animation map data is good
1622 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1623 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1624 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1625 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1626 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1627 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1628 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1632 // Case 2 : Set values by string
1634 tet_printf(" - Set Values by String\n");
1635 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1636 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1637 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1639 tet_printf("test with delay [%f]\n", _delay);
1640 VisualFactory factory = VisualFactory::Get();
1641 DALI_TEST_CHECK(factory);
1643 Property::Map propertyMap;
1644 Property::Map animationMap;
1645 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1647 float duration = 1.1f;
1648 float delay = _delay;
1649 float repeat_delay = 0.4f;
1651 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1653 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1654 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1656 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1657 animationMap.Clear();
1658 animationMap.Insert("startValue", start);
1659 animationMap.Insert("targetValue", target);
1660 animationMap.Insert("directionType", "BACKWARD");
1661 animationMap.Insert("duration", duration);
1662 animationMap.Insert("delay", delay);
1663 animationMap.Insert("repeat", loop_count);
1664 animationMap.Insert("repeatDelay", repeat_delay);
1665 animationMap.Insert("motionType", "MIRROR");
1666 animationMap.Insert("easingType", "IN_OUT");
1668 return animationMap;
1671 Vector2 start1(-0.5f, 0.5f);
1672 Vector2 end1(0.5f, -0.5f);
1673 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1674 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1675 Vector2 rotate_center1(0.0f, 0.4f);
1676 float rotate_amount1 = 0.0f;
1677 float offset1 = 0.f;
1679 Vector2 start2(-0.5f, -0.5f);
1680 Vector2 end2(0.5f, 0.5f);
1681 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1682 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1683 Vector2 rotate_center2(0.0f, -0.4f);
1684 float rotate_amount2 = 6.2832f;
1685 float offset2 = 2.f;
1687 // For test mix the type string/index key and string/index value works well.
1688 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1689 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1690 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1692 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1693 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1694 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1695 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1696 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1697 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1698 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1700 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1701 DALI_TEST_CHECK(animatedGradientVisual);
1703 Property::Map resultMap;
1704 animatedGradientVisual.CreatePropertyMap(resultMap);
1706 // check the property values from the returned map from visual
1707 // Note : resultMap from CreatePropertyMap only contain indexKey
1708 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1709 DALI_TEST_CHECK(value);
1710 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1712 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1713 DALI_TEST_CHECK(value);
1714 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1716 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1717 DALI_TEST_CHECK(value);
1718 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1720 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1721 DALI_TEST_CHECK(value);
1722 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1724 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 {
1725 tet_printf("Check value at %d\n", line_num);
1726 value = resultMap.Find(index, Property::MAP);
1727 DALI_TEST_CHECK(value);
1728 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1729 Property::Map* temp_map = value->GetMap();
1730 DALI_TEST_CHECK(temp_map);
1732 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1733 Property::Value* res = temp_map->Find(index);
1734 DALI_TEST_CHECK(res);
1738 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1739 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1740 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1741 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1742 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1743 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1744 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1745 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1746 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1749 // check the animation map data is good
1750 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1751 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1752 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1753 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1754 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1755 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1756 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1762 int UtcDaliVisualGetPropertyMap13(void)
1764 ToolkitTestApplication application;
1765 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1767 for(int _direction = 0; _direction <= 1; ++_direction)
1769 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1771 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1772 VisualFactory factory = VisualFactory::Get();
1773 DALI_TEST_CHECK(factory);
1775 Property::Map propertyMap;
1776 Property::Map animationMap;
1777 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1779 float duration = 1.0f;
1780 float delay = _delay;
1781 float repeat_delay = 0.5f;
1783 int direction = _direction;
1784 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1785 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1786 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1788 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1789 animationMap.Clear();
1790 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1791 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1793 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1795 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1796 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1797 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1798 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1799 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1800 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1801 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1802 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1804 return animationMap;
1807 Vector2 start1(-0.5f, 0.5f);
1808 Vector2 end1(0.5f, -0.5f);
1809 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1810 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1811 Vector2 rotate_center1(1.0f, 0.4f);
1812 float rotate_amount1 = 2.0f;
1813 float offset1 = 1.f;
1815 Vector2 start2(-0.5f, -0.5f);
1816 Vector2 end2(0.5f, 0.5f);
1817 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1818 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1819 Vector2 rotate_center2(1.0f, -0.4f);
1820 float rotate_amount2 = 1.0f;
1821 float offset2 = 3.f;
1823 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1824 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1825 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1827 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1828 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1829 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1830 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1831 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1832 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1833 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1835 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1836 DALI_TEST_CHECK(animatedGradientVisual);
1838 Property::Map resultMap;
1839 animatedGradientVisual.CreatePropertyMap(resultMap);
1841 // check the property values from the returned map from visual
1842 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1843 DALI_TEST_CHECK(value);
1844 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1846 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1847 DALI_TEST_CHECK(value);
1848 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1850 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1851 DALI_TEST_CHECK(value);
1852 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1854 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1855 DALI_TEST_CHECK(value);
1856 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1858 // If loop_count = 0, Animation doesn't created.
1859 // Optimized resultMap only have one value, which is target value
1860 // Note: target value will be changed by direction option.
1861 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1862 DALI_TEST_CHECK(value);
1863 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1865 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1866 DALI_TEST_CHECK(value);
1867 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1869 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1870 DALI_TEST_CHECK(value);
1871 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1873 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1874 DALI_TEST_CHECK(value);
1875 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1877 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1878 DALI_TEST_CHECK(value);
1879 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1881 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1882 DALI_TEST_CHECK(value);
1883 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1885 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1886 DALI_TEST_CHECK(value);
1887 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1894 int UtcDaliVisualAnimateArcVisual(void)
1896 ToolkitTestApplication application;
1897 tet_infoline("UtcDaliVisualAnimateArcVisual color");
1899 static std::vector<UniformData> customUniforms =
1901 UniformData("startAngle", Property::Type::FLOAT),
1902 UniformData("sweepAngle", Property::Type::FLOAT),
1905 TestGraphicsController& graphics = application.GetGraphicsController();
1906 graphics.AddCustomUniforms(customUniforms);
1908 VisualFactory factory = VisualFactory::Get();
1909 Property::Map propertyMap;
1910 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ARC);
1911 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1912 propertyMap.Insert(DevelArcVisual::Property::START_ANGLE, 0.0f);
1913 propertyMap.Insert(DevelArcVisual::Property::SWEEP_ANGLE, 90.0f);
1914 propertyMap.Insert(DevelArcVisual::Property::CAP, DevelArcVisual::Cap::ROUND);
1915 propertyMap.Insert(DevelArcVisual::Property::THICKNESS, 20.0f);
1916 Visual::Base arcVisual = factory.CreateVisual(propertyMap);
1918 DummyControl actor = DummyControl::New(true);
1919 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1920 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, arcVisual);
1921 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1922 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1923 application.GetScene().Add(actor);
1925 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1927 Renderer renderer = actor.GetRendererAt(0);
1928 Property::Index index = renderer.GetPropertyIndex(DevelArcVisual::Property::SWEEP_ANGLE);
1930 Animation animation = Animation::New(4.0f);
1931 animation.AnimateTo(Property(renderer, index), 50.0f);
1932 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelArcVisual::Property::START_ANGLE), 40.0f);
1935 application.SendNotification();
1936 application.Render(0);
1937 application.Render(2000u); // halfway point
1939 float sweepAngle = renderer.GetCurrentProperty<float>(index);
1940 DALI_TEST_EQUALS(sweepAngle, 70.0f, 0.0001f, TEST_LOCATION);
1941 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 20.0f), true, TEST_LOCATION);
1942 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 70.0f), true, TEST_LOCATION);
1944 application.Render(2000u); // another halfway point
1946 sweepAngle = renderer.GetCurrentProperty<float>(index);
1947 DALI_TEST_EQUALS(sweepAngle, 50.0f, 0.0001f, TEST_LOCATION);
1948 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 40.0f), true, TEST_LOCATION);
1949 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 50.0f), true, TEST_LOCATION);
1954 int UtcDaliVisualAnimateBorderVisual01(void)
1956 ToolkitTestApplication application;
1957 tet_infoline("UtcDaliAnimateBorderVisual Color");
1959 static std::vector<UniformData> customUniforms =
1961 UniformData("borderColor", Property::Type::VECTOR4),
1962 UniformData("mixColor", Property::Type::VECTOR3),
1965 TestGraphicsController& graphics = application.GetGraphicsController();
1966 graphics.AddCustomUniforms(customUniforms);
1968 VisualFactory factory = VisualFactory::Get();
1969 Property::Map propertyMap;
1970 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1971 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1972 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1973 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1974 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1977 map["target"] = "testVisual";
1978 map["property"] = "mixColor";
1979 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1980 map["animator"] = Property::Map()
1981 .Add("alphaFunction", "LINEAR")
1982 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1984 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1986 DummyControl actor = DummyControl::New(true);
1987 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1988 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1989 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1990 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1991 application.GetScene().Add(actor);
1993 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1995 Renderer renderer = actor.GetRendererAt(0);
1996 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1997 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1999 Animation animation = dummyImpl.CreateTransition(transition);
2001 // Animate the mix color through the transition, and the border color through
2002 // programmatic method.
2003 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
2006 application.SendNotification();
2007 application.Render(0);
2008 application.Render(2000u); // halfway point between blue and white
2010 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
2011 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
2012 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2013 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
2015 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2016 testColor = Vector4(1, 1, 1, 0.45f);
2017 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
2018 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
2021 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
2022 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
2024 application.Render(2000u);
2026 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
2027 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
2028 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
2030 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2031 testColor = Vector4(1, 1, 1, 0.1);
2032 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
2033 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
2035 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
2036 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
2041 int UtcDaliVisualAnimateBorderVisual02(void)
2043 ToolkitTestApplication application;
2044 tet_infoline("UtcDaliAnimateBorderVisual Size");
2046 static std::vector<UniformData> customUniforms =
2048 UniformData("borderSize", Property::Type::FLOAT),
2051 TestGraphicsController& graphics = application.GetGraphicsController();
2052 graphics.AddCustomUniforms(customUniforms);
2054 VisualFactory factory = VisualFactory::Get();
2055 Property::Map propertyMap;
2056 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
2057 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
2058 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
2059 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
2061 DummyControl actor = DummyControl::New(true);
2062 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2063 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
2064 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2065 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2066 application.GetScene().Add(actor);
2068 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2070 Renderer renderer = actor.GetRendererAt(0);
2071 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
2073 Animation animation = Animation::New(4.0f);
2074 animation.AnimateTo(Property(renderer, index), 9.0f);
2077 application.SendNotification();
2078 application.Render(0);
2079 application.Render(2000u); // halfway point
2081 float size = renderer.GetCurrentProperty<float>(index);
2082 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
2083 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
2085 application.Render(2000u); // halfway point between blue and white
2087 size = renderer.GetCurrentProperty<float>(index);
2088 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
2089 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
2094 int UtcDaliVisualAnimateColorVisual(void)
2096 ToolkitTestApplication application;
2097 tet_infoline("UtcDaliAnimateColorVisual mixColor");
2099 static std::vector<UniformData> customUniforms =
2101 UniformData("mixColor", Property::Type::VECTOR3),
2104 TestGraphicsController& graphics = application.GetGraphicsController();
2105 graphics.AddCustomUniforms(customUniforms);
2107 VisualFactory factory = VisualFactory::Get();
2108 Property::Map propertyMap;
2109 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2110 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2111 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
2113 DummyControl actor = DummyControl::New(true);
2114 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2115 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
2116 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2117 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2118 application.GetScene().Add(actor);
2120 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2122 Renderer renderer = actor.GetRendererAt(0);
2123 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
2125 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
2126 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2128 Animation animation = Animation::New(4.0f);
2129 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2132 application.SendNotification();
2133 application.Render(0);
2134 application.Render(2000u); // halfway point
2136 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2137 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2138 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2140 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2142 application.Render(2000u); // halfway point between blue and white
2144 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2145 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2147 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2149 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2150 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2155 int UtcDaliVisualAnimatePrimitiveVisual(void)
2157 ToolkitTestApplication application;
2158 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2160 static std::vector<UniformData> customUniforms =
2162 UniformData("mixColor", Property::Type::VECTOR3),
2165 TestGraphicsController& graphics = application.GetGraphicsController();
2166 graphics.AddCustomUniforms(customUniforms);
2169 VisualFactory factory = VisualFactory::Get();
2170 Property::Map propertyMap;
2171 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2172 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2173 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2174 Visual::Base visual = factory.CreateVisual(propertyMap);
2176 DummyControl actor = DummyControl::New(true);
2177 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2178 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2179 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2180 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2181 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2182 application.GetScene().Add(actor);
2184 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2186 Renderer renderer = actor.GetRendererAt(0);
2188 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2189 const Vector4 TARGET_MIX_COLOR(Color::RED);
2192 map["target"] = "testVisual";
2193 map["property"] = "mixColor";
2194 map["initialValue"] = INITIAL_MIX_COLOR;
2195 map["targetValue"] = TARGET_MIX_COLOR;
2196 map["animator"] = Property::Map()
2197 .Add("alphaFunction", "LINEAR")
2198 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2200 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2202 Animation animation = dummyImpl.CreateTransition(transition);
2203 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2206 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2207 glAbstraction.EnableEnableDisableCallTrace(true);
2208 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2209 std::ostringstream blendStr;
2210 blendStr << std::hex << GL_BLEND;
2212 application.SendNotification();
2213 application.Render(0);
2214 application.Render(2000u); // halfway point
2215 application.SendNotification();
2217 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2218 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2219 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2221 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2223 glEnableStack.Reset();
2225 application.Render(2001u); // go past end
2226 application.SendNotification(); // Trigger signals
2228 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2229 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2230 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2232 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2240 int UtcDaliVisualAnimatedGradientVisual01(void)
2242 ToolkitTestApplication application;
2243 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2245 static std::vector<UniformData> customUniforms =
2247 UniformData("start_point", Property::Type::VECTOR2),
2248 UniformData("end_point", Property::Type::VECTOR2),
2249 UniformData("start_color", Property::Type::VECTOR4),
2250 UniformData("end_color", Property::Type::VECTOR4),
2251 UniformData("rotate_center", Property::Type::VECTOR2),
2252 UniformData("rotate_angle", Property::Type::FLOAT),
2253 UniformData("gradient_offset", Property::Type::FLOAT),
2256 TestGraphicsController& graphics = application.GetGraphicsController();
2257 graphics.AddCustomUniforms(customUniforms);
2260 VisualFactory factory = VisualFactory::Get();
2261 Property::Map propertyMap;
2262 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2263 Visual::Base visual = factory.CreateVisual(propertyMap);
2265 DummyControl actor = DummyControl::New(true);
2266 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2267 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2268 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2269 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2270 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2271 application.GetScene().Add(actor);
2273 application.SendNotification();
2274 application.Render(0);
2275 application.SendNotification();
2277 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2279 for(int step_iter = 0; step_iter < 3; step_iter++)
2281 application.SendNotification();
2282 application.Render(0);
2283 application.Render(750u); // step i/4
2284 application.SendNotification();
2286 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2287 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2288 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2289 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2290 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2291 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2292 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2295 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2296 application.Render(750u); // go to end
2297 application.SendNotification();
2299 application.Render(10u); // finish
2300 application.SendNotification();
2303 application.SendNotification();
2304 application.Render(0u);
2305 application.SendNotification();
2311 int UtcDaliVisualAnimatedGradientVisual02(void)
2313 ToolkitTestApplication application;
2314 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2316 static std::vector<UniformData> customUniforms =
2318 UniformData("start_point", Property::Type::VECTOR2),
2319 UniformData("end_point", Property::Type::VECTOR2),
2320 UniformData("start_color", Property::Type::VECTOR4),
2321 UniformData("end_color", Property::Type::VECTOR4),
2322 UniformData("rotate_center", Property::Type::VECTOR2),
2323 UniformData("rotate_angle", Property::Type::FLOAT),
2324 UniformData("gradient_offset", Property::Type::FLOAT),
2327 TestGraphicsController& graphics = application.GetGraphicsController();
2328 graphics.AddCustomUniforms(customUniforms);
2331 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
2332 int _direction[2] = {0, 1};
2333 int _loop_count[3] = {-1, 0, 1};
2334 int _motion[2] = {0, 1};
2335 int _easing[4] = {0, 1, 2, 3};
2337 int test_case_max = 4 * 2 * 3 * 2 * 4;
2339 int test_case_d = 7; // 7 is the number of animated properties.
2341 float _duration = 0.4f;
2342 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2343 float noise_maker = 0.0f;
2344 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2345 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2347 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2349 VisualFactory factory = VisualFactory::Get();
2350 Property::Map propertyMap;
2351 Property::Map animationMap;
2352 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2354 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2355 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2356 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2358 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& {
2359 int tc = (test_case + tc_offset);
2360 int idx_easing = tc % 4;
2362 int idx_motion = tc % 2;
2364 int idx_loop_count = tc % 3;
2366 int idx_direction = tc % 2;
2368 int idx_delay = tc % 4;
2371 float duration = _duration - _repeat_delay;
2372 float repeat_delay = _repeat_delay;
2373 float delay = _delay[idx_delay] * _duration;
2374 int direction = _direction[idx_direction];
2375 int loop_count = _loop_count[idx_loop_count];
2376 int motion = _motion[idx_motion];
2377 int easing = _easing[idx_easing];
2379 animationMap.Clear();
2380 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2381 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2384 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2388 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2390 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2391 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2392 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2393 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2396 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2400 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2404 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2406 else if(easing == 1)
2408 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2410 else if(easing == 2)
2412 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2416 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2419 return animationMap;
2422 // Give different values for debuging
2423 noise_maker += 1.0f;
2424 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2425 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2426 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2427 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2428 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2429 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2430 float offset1 = 0.f + noise_maker * 0.1f;
2432 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2433 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2434 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2435 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2436 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2437 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2438 float offset2 = 2.f + noise_maker * 0.1f;
2440 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2441 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2442 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2444 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2445 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2446 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2447 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2448 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2449 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2450 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2452 Visual::Base visual = factory.CreateVisual(propertyMap);
2454 DummyControl actor = DummyControl::New(true);
2455 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2456 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2457 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2458 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2459 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2460 application.GetScene().Add(actor);
2462 application.SendNotification();
2463 application.Render(0);
2464 application.SendNotification();
2466 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2468 application.SendNotification();
2470 //Compare between CPU calculated value and Shader Visual calculated value
2471 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 {
2472 int tc = (test_case + tc_offset);
2473 int idx_easing = tc % 4;
2475 int idx_motion = tc % 2;
2477 int idx_loop_count = tc % 3;
2479 int idx_direction = tc % 2;
2481 int idx_delay = tc % 4;
2484 float duration = _duration - _repeat_delay;
2485 float repeat_delay = _repeat_delay;
2486 float delay = _delay[idx_delay] * _duration;
2487 int direction = _direction[idx_direction];
2488 int loop_count = _loop_count[idx_loop_count];
2489 int motion = _motion[idx_motion];
2490 int easing = _easing[idx_easing];
2492 progress -= delay / _duration;
2494 Property::Value s = start;
2495 Property::Value t = target;
2501 float x; ///< Animator progress value
2506 else if(loop_count > 0 && progress + 0.01f > loop_count)
2508 x = (motion == 0) ? 1.0f : 0.0f;
2516 progress = fmodf(progress, 1.0f);
2517 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2522 x = progress * 2.0f;
2529 if(easing == 1) // EASE_IN
2533 else if(easing == 2) // EASE_OUT
2535 x = 2.0f * x - x * x;
2537 else if(easing == 3) // EASE_IN_OUT
2539 x = x * x * (3.0f - 2.0f * x);
2542 if(value_type == 0) // result type is Float
2546 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2547 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2548 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2550 else if(value_type == 1) // result type is Vector2
2554 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2555 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2556 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2558 else if(value_type == 2) // result type is Vector3
2562 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2563 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2564 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2566 else // result type is Vector4
2570 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2571 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2572 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2577 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2579 for(int step_iter = 0; step_iter < 3; step_iter++)
2581 application.SendNotification();
2582 application.Render(_duration * 250.f); // step i/4
2583 application.SendNotification();
2586 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2587 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2588 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2589 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2590 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2591 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2592 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2594 application.SendNotification();
2595 application.Render(_duration * 250.f); // step 4/4 will not test
2596 application.SendNotification();
2600 application.SendNotification();
2602 application.SendNotification();
2603 application.Render(10.f); // tempral time
2604 application.SendNotification();
2611 int UtcDaliVisualAnimatedGradientVisual03(void)
2613 ToolkitTestApplication application;
2614 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2616 static std::vector<UniformData> customUniforms =
2618 UniformData("start_point", Property::Type::VECTOR2),
2619 UniformData("end_point", Property::Type::VECTOR2),
2620 UniformData("start_color", Property::Type::VECTOR4),
2621 UniformData("end_color", Property::Type::VECTOR4),
2622 UniformData("rotate_center", Property::Type::VECTOR2),
2623 UniformData("rotate_angle", Property::Type::FLOAT),
2624 UniformData("gradient_offset", Property::Type::FLOAT),
2627 TestGraphicsController& graphics = application.GetGraphicsController();
2628 graphics.AddCustomUniforms(customUniforms);
2631 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
2632 int _direction[2] = {0, 1};
2633 int _loop_count[3] = {-1, 0, 1};
2634 int _motion[2] = {0, 1};
2635 int _easing[4] = {0, 1, 2, 3};
2637 int test_case_max = 4 * 2 * 3 * 2 * 4;
2639 int test_case_d = 7; // 7 is the number of animated properties.
2641 float _duration = 0.4f;
2642 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2643 float noise_maker = 0.2f;
2644 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2645 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2647 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2649 VisualFactory factory = VisualFactory::Get();
2650 Property::Map propertyMap;
2651 Property::Map animationMap;
2652 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2654 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& {
2655 int tc = (test_case + tc_offset);
2656 int idx_easing = tc % 4;
2658 int idx_motion = tc % 2;
2660 int idx_loop_count = tc % 3;
2662 int idx_direction = tc % 2;
2664 int idx_delay = tc % 4;
2667 float duration = _duration - _repeat_delay;
2668 float repeat_delay = _repeat_delay;
2669 float delay = _delay[idx_delay] * _duration;
2670 int direction = _direction[idx_direction];
2671 int loop_count = _loop_count[idx_loop_count];
2672 int motion = _motion[idx_motion];
2673 int easing = _easing[idx_easing];
2675 animationMap.Clear();
2676 animationMap.Insert("startValue", start);
2677 animationMap.Insert("targetValue", target);
2680 animationMap.Insert("directionType", "FORWARD");
2684 animationMap.Insert("directionType", "BACKWARD");
2686 animationMap.Insert("duration", duration);
2687 animationMap.Insert("delay", delay);
2688 animationMap.Insert("repeat", loop_count);
2689 animationMap.Insert("repeatDelay", repeat_delay);
2692 animationMap.Insert("motionType", "LOOP");
2696 animationMap.Insert("motionType", "MIRROR");
2700 animationMap.Insert("easingType", "LINEAR");
2702 else if(easing == 1)
2704 animationMap.Insert("easingType", "IN");
2706 else if(easing == 2)
2708 animationMap.Insert("easingType", "OUT");
2712 animationMap.Insert("easingType", "IN_OUT");
2715 return animationMap;
2718 // Give different values for debuging
2719 noise_maker += 0.8f;
2720 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2721 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2722 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2723 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2724 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2725 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2726 float offset1 = 0.f + noise_maker * 0.1f;
2728 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2729 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2730 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2731 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2732 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2733 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2734 float offset2 = 2.f + noise_maker * 0.1f;
2736 propertyMap.Insert("gradientType", "LINEAR");
2737 propertyMap.Insert("unitType", "USER_SPACE");
2738 propertyMap.Insert("spreadType", "CLAMP");
2740 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2741 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2742 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2743 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2744 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2745 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2746 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2748 Visual::Base visual = factory.CreateVisual(propertyMap);
2750 DummyControl actor = DummyControl::New(true);
2751 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2752 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2753 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2754 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2755 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2756 application.GetScene().Add(actor);
2758 application.SendNotification();
2759 application.Render(0);
2760 application.SendNotification();
2762 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2764 application.SendNotification();
2766 //Compare between CPU calculated value and Shader Visual calculated value
2767 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 {
2768 int tc = (test_case + tc_offset);
2769 int idx_easing = tc % 4;
2771 int idx_motion = tc % 2;
2773 int idx_loop_count = tc % 3;
2775 int idx_direction = tc % 2;
2777 int idx_delay = tc % 4;
2780 float duration = _duration - _repeat_delay;
2781 float repeat_delay = _repeat_delay;
2782 float delay = _delay[idx_delay] * _duration;
2783 int direction = _direction[idx_direction];
2784 int loop_count = _loop_count[idx_loop_count];
2785 int motion = _motion[idx_motion];
2786 int easing = _easing[idx_easing];
2788 progress -= delay / _duration;
2790 Property::Value s = start;
2791 Property::Value t = target;
2797 float x; ///< Animator progress value
2802 else if(loop_count > 0 && progress + 0.01f > loop_count)
2804 x = (motion == 0) ? 1.0f : 0.0f;
2812 progress = fmodf(progress, 1.0f);
2813 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2818 x = progress * 2.0f;
2825 if(easing == 1) // EASE_IN
2829 else if(easing == 2) // EASE_OUT
2831 x = 2.0f * x - x * x;
2833 else if(easing == 3) // EASE_IN_OUT
2835 x = x * x * (3.0f - 2.0f * x);
2838 if(value_type == 0) // result type is Float
2842 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2843 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2844 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2846 else if(value_type == 1) // result type is Vector2
2850 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2851 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2852 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2854 else if(value_type == 2) // result type is Vector3
2858 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2859 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2860 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2862 else // result type is Vector4
2866 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2867 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2868 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2873 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2875 for(int step_iter = 0; step_iter < 3; step_iter++)
2877 application.SendNotification();
2878 application.Render(_duration * 250.f); // step i/4
2879 application.SendNotification();
2882 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2883 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2884 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2885 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2886 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2887 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2888 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2890 application.SendNotification();
2891 application.Render(_duration * 250.f); // step 4/4 will not test
2892 application.SendNotification();
2896 application.SendNotification();
2898 application.SendNotification();
2899 application.Render(10.f); // tempral time
2900 application.SendNotification();
2907 int UtcDaliVisualWireframeVisual(void)
2909 ToolkitTestApplication application;
2911 VisualFactory factory = VisualFactory::Get();
2912 Property::Map propertyMap;
2913 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2915 // Create the visual.
2916 Visual::Base visual = factory.CreateVisual(propertyMap);
2918 DALI_TEST_CHECK(visual);
2920 Property::Map resultMap;
2921 visual.CreatePropertyMap(resultMap);
2923 // Check the property values from the returned map from visual
2924 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2925 DALI_TEST_CHECK(value);
2926 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2931 int UtcDaliVisualGetTransform(void)
2933 ToolkitTestApplication application;
2934 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2936 VisualFactory factory = VisualFactory::Get();
2937 Property::Map propertyMap;
2938 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2939 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2940 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2942 Dali::Property::Map visualMap;
2943 colorVisual.CreatePropertyMap(visualMap);
2944 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2945 Dali::Property::Map* map = value->GetMap();
2946 DALI_TEST_CHECK(map);
2948 //Test default values
2950 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2951 DALI_TEST_CHECK(typeValue);
2952 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2955 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2956 DALI_TEST_CHECK(typeValue);
2957 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2960 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2961 DALI_TEST_CHECK(typeValue);
2962 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2965 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2966 DALI_TEST_CHECK(typeValue);
2967 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2970 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2971 DALI_TEST_CHECK(typeValue);
2972 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2975 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2976 DALI_TEST_CHECK(typeValue);
2977 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2980 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2981 DALI_TEST_CHECK(typeValue);
2982 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2988 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2990 Property::Map transform;
2991 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2992 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2993 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2994 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2995 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2996 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2998 visual.SetTransformAndSize(transform, Vector2(100, 100));
3000 Dali::Property::Map visualMap;
3001 visual.CreatePropertyMap(visualMap);
3002 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3003 Dali::Property::Map* map = value->GetMap();
3004 DALI_TEST_CHECK(map);
3007 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
3008 DALI_TEST_CHECK(typeValue);
3009 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
3012 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
3013 DALI_TEST_CHECK(typeValue);
3014 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
3017 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3018 DALI_TEST_CHECK(typeValue);
3019 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3022 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3023 DALI_TEST_CHECK(typeValue);
3024 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3027 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
3028 DALI_TEST_CHECK(typeValue);
3029 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
3032 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
3033 DALI_TEST_CHECK(typeValue);
3034 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
3037 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
3038 DALI_TEST_CHECK(typeValue);
3039 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
3042 //Put the visual on the stage
3043 DummyControl actor = DummyControl::New(true);
3044 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
3045 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3046 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3047 application.GetScene().Add(actor);
3049 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3050 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
3052 application.SendNotification();
3053 application.Render(0);
3054 Renderer renderer(actor.GetRendererAt(0));
3056 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
3057 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
3059 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
3060 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
3062 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
3063 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
3065 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3066 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
3068 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3069 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3071 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3072 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
3074 //Set a new transform
3076 transform = DefaultTransform();
3077 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
3078 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
3079 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
3080 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
3081 visual.SetTransformAndSize(transform, Vector2(100, 100));
3082 application.SendNotification();
3083 application.Render(0);
3085 //Check that the values have changed in the renderer
3086 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
3087 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
3089 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
3090 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
3092 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
3093 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
3095 //Parent origin and anchor point should have the default values
3096 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3097 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3099 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3100 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
3102 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3103 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
3106 int UtcDaliVisualSetTransform01(void)
3108 ToolkitTestApplication application;
3109 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3111 VisualFactory factory = VisualFactory::Get();
3112 Property::Map propertyMap;
3113 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3114 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
3115 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3116 Visual::Base visual = factory.CreateVisual(propertyMap);
3117 TestTransform(application, visual);
3118 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3123 int UtcDaliVisualSetTransform0(void)
3125 ToolkitTestApplication application;
3126 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3128 VisualFactory factory = VisualFactory::Get();
3129 Property::Map propertyMap;
3130 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3131 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3132 Visual::Base visual = factory.CreateVisual(propertyMap);
3133 TestTransform(application, visual);
3134 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3139 int UtcDaliVisualSetTransform1(void)
3141 ToolkitTestApplication application;
3142 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3144 VisualFactory factory = VisualFactory::Get();
3145 Property::Map propertyMap;
3146 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3147 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3148 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3149 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3150 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3151 Visual::Base visual = factory.CreateVisual(propertyMap);
3152 TestTransform(application, visual);
3153 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3158 int UtcDaliVisualSetTransform2(void)
3160 ToolkitTestApplication application;
3161 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3163 VisualFactory factory = VisualFactory::Get();
3164 Property::Map propertyMap;
3165 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3166 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3168 Property::Array stopOffsets;
3169 stopOffsets.PushBack(0.0f);
3170 stopOffsets.PushBack(0.3f);
3171 stopOffsets.PushBack(0.6f);
3172 stopOffsets.PushBack(0.8f);
3173 stopOffsets.PushBack(1.0f);
3174 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3176 Property::Array stopColors;
3177 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3178 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3179 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3180 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3181 stopColors.PushBack(Color::YELLOW);
3182 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3183 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3184 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3185 Visual::Base visual = factory.CreateVisual(propertyMap);
3186 TestTransform(application, visual);
3187 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3192 int UtcDaliVisualSetTransform3(void)
3194 ToolkitTestApplication application;
3195 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3197 VisualFactory factory = VisualFactory::Get();
3198 Property::Map propertyMap;
3199 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3200 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3201 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3202 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3203 Visual::Base visual = factory.CreateVisual(propertyMap);
3204 TestTransform(application, visual);
3205 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3210 int UtcDaliVisualSetTransform4(void)
3212 ToolkitTestApplication application;
3213 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3215 VisualFactory factory = VisualFactory::Get();
3216 Property::Map propertyMap;
3217 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3218 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3220 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3221 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3222 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3223 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3224 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3225 Visual::Base visual = factory.CreateVisual(propertyMap);
3226 TestTransform(application, visual);
3227 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3232 int UtcDaliVisualSetTransform5(void)
3234 ToolkitTestApplication application;
3235 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3237 VisualFactory factory = VisualFactory::Get();
3238 Property::Map propertyMap;
3239 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3240 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3241 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3242 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3243 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3244 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3245 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3246 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3247 Visual::Base visual = factory.CreateVisual(propertyMap);
3248 TestTransform(application, visual);
3249 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3254 int UtcDaliVisualSetTransform6(void)
3256 ToolkitTestApplication application;
3257 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3259 VisualFactory factory = VisualFactory::Get();
3260 Property::Map propertyMap;
3261 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3262 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3263 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3264 Visual::Base visual = factory.CreateVisual(propertyMap);
3265 TestTransform(application, visual);
3266 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3271 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3273 ToolkitTestApplication application;
3274 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3276 VisualFactory factory = VisualFactory::Get();
3277 Property::Map propertyMap;
3278 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3279 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3280 Visual::Base visual = factory.CreateVisual(propertyMap);
3282 Property::Map transform;
3283 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3284 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3285 visual.SetTransformAndSize(transform, Vector2(100, 100));
3287 Dali::Property::Map visualMap;
3288 visual.CreatePropertyMap(visualMap);
3289 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3290 Dali::Property::Map* map = value->GetMap();
3291 DALI_TEST_CHECK(map);
3294 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3295 DALI_TEST_CHECK(typeValue);
3296 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3299 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3300 DALI_TEST_CHECK(typeValue);
3301 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3307 int UtcDaliNPatchVisualCustomShader(void)
3309 ToolkitTestApplication application;
3310 tet_infoline("NPatchVisual with custom shader");
3312 VisualFactory factory = VisualFactory::Get();
3313 Property::Map properties;
3314 Property::Map shader;
3315 const std::string vertexShader = "Foobar";
3316 const std::string fragmentShader = "Foobar";
3317 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3318 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3320 Property::Map transformMap;
3321 transformMap["size"] = Vector2(0.5f, 0.5f);
3322 transformMap["offset"] = Vector2(20.0f, 0.0f);
3323 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3324 transformMap["anchorPoint"] = Align::CENTER;
3325 transformMap["origin"] = Align::CENTER;
3326 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3327 properties[Visual::Property::TRANSFORM] = transformMap;
3329 properties[Visual::Property::TYPE] = Visual::IMAGE;
3330 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3331 properties[Visual::Property::SHADER] = shader;
3332 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3333 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3335 Visual::Base visual = factory.CreateVisual(properties);
3336 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3338 // trigger creation through setting on stage
3339 DummyControl dummy = DummyControl::New(true);
3340 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3341 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3342 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3343 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3344 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3345 application.GetScene().Add(dummy);
3346 application.SendNotification();
3348 Renderer renderer = dummy.GetRendererAt(0);
3349 Shader shader2 = renderer.GetShader();
3350 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3351 Property::Map* map = value.GetMap();
3352 DALI_TEST_CHECK(map);
3354 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3355 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3357 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3358 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3360 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3361 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3363 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3364 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3369 int UtcDaliGradientVisualBlendMode(void)
3371 ToolkitTestApplication application;
3372 VisualFactory factory = VisualFactory::Get();
3374 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3375 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)));
3377 Visual::Base alphaGradientVisual = factory.CreateVisual(
3378 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))));
3380 DummyControl control = DummyControl::New(true);
3381 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3382 application.GetScene().Add(control);
3384 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3385 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3386 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3388 application.SendNotification();
3389 application.Render();
3391 // 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
3392 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3393 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3394 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3399 int UtcDaliVisualRendererRemovalAndReAddition(void)
3401 ToolkitTestApplication application;
3402 tet_infoline("UtcDaliVisualRendererRemoval");
3404 VisualFactory factory = VisualFactory::Get();
3405 Property::Map propertyMap;
3406 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3407 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3408 Visual::Base visual = factory.CreateVisual(propertyMap);
3410 visual.SetDepthIndex(1);
3412 DummyControl dummyControl = DummyControl::New(true);
3413 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3414 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3415 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3417 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3418 tet_infoline("Add control with visual to stage and check renderer count is 1");
3420 application.GetScene().Add(dummyControl);
3422 application.SendNotification();
3423 application.Render();
3425 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3427 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3428 application.GetScene().Remove(dummyControl);
3429 application.SendNotification();
3430 application.Render();
3432 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3434 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3436 application.GetScene().Add(dummyControl);
3438 application.SendNotification();
3439 application.Render();
3441 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3446 int UtcDaliVisualTextVisualRender(void)
3448 ToolkitTestApplication application;
3449 tet_infoline("UtcDaliVisualTextVisualRender");
3451 VisualFactory factory = VisualFactory::Get();
3452 Property::Map propertyMap;
3453 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3454 propertyMap.Insert("mixColor", Color::WHITE);
3455 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3456 propertyMap.Insert("enableMarkup", false);
3457 propertyMap.Insert("text", "Hello world");
3458 propertyMap.Insert("fontFamily", "TizenSans");
3460 Property::Map fontStyleMapSet;
3461 fontStyleMapSet.Insert("weight", "bold");
3462 propertyMap.Insert("fontStyle", fontStyleMapSet);
3464 propertyMap.Insert("pointSize", 12.f);
3465 propertyMap.Insert("multiLine", true);
3466 propertyMap.Insert("horizontalAlignment", "CENTER");
3467 propertyMap.Insert("verticalAlignment", "CENTER");
3468 propertyMap.Insert("textColor", Color::RED);
3469 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3470 textVisual.SetDepthIndex(1);
3472 DummyControl dummyControl = DummyControl::New(true);
3473 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3474 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3475 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3477 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3478 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3480 application.GetScene().Add(dummyControl);
3481 application.SendNotification();
3482 application.Render();
3484 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3485 propertyMap.Clear();
3486 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3487 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3488 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3489 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3491 Property::Map transformMap;
3492 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3493 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3495 textVisual = factory.CreateVisual(propertyMap);
3496 textVisual.SetDepthIndex(1);
3498 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3499 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3501 application.SendNotification(); // force process events to ensure text visual
3502 // adds renderer to the dummy control in OnRelayout
3503 application.Render();
3505 Renderer renderer = dummyControl.GetRendererAt(0u);
3506 Property::Index index = renderer.GetPropertyIndex("transformSize");
3508 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3509 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3514 int UtcDaliVisualTextVisualDisableEnable(void)
3516 ToolkitTestApplication application;
3517 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3519 VisualFactory factory = VisualFactory::Get();
3520 Property::Map propertyMap;
3521 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3522 propertyMap.Insert("mixColor", Color::WHITE);
3523 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3524 propertyMap.Insert("enableMarkup", false);
3525 propertyMap.Insert("text", "Hello world");
3526 propertyMap.Insert("fontFamily", "TizenSans");
3528 Property::Map fontStyleMapSet;
3529 fontStyleMapSet.Insert("weight", "bold");
3530 propertyMap.Insert("fontStyle", fontStyleMapSet);
3532 propertyMap.Insert("pointSize", 12.f);
3533 propertyMap.Insert("multiLine", true);
3534 propertyMap.Insert("horizontalAlignment", "CENTER");
3535 propertyMap.Insert("verticalAlignment", "CENTER");
3536 propertyMap.Insert("textColor", Color::RED);
3537 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3538 textVisual.SetDepthIndex(1);
3540 DummyControl dummyControl = DummyControl::New(true);
3541 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3542 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3543 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3545 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3546 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3548 application.GetScene().Add(dummyControl);
3549 application.SendNotification();
3550 application.Render();
3552 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3554 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3556 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3558 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3560 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3565 int UtcDaliVisualPremultipliedAlpha(void)
3567 ToolkitTestApplication application;
3568 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3570 VisualFactory factory = VisualFactory::Get();
3572 // image visual, test default value ( true )
3574 Visual::Base imageVisual = factory.CreateVisual(
3576 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3577 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3579 Dali::Property::Map visualMap;
3580 imageVisual.CreatePropertyMap(visualMap);
3581 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3584 DALI_TEST_CHECK(value);
3585 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3588 // image visual, override premultiplied
3590 Visual::Base imageVisual = factory.CreateVisual(
3592 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3593 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3594 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3596 Dali::Property::Map visualMap;
3597 imageVisual.CreatePropertyMap(visualMap);
3598 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3601 DALI_TEST_CHECK(value);
3602 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3605 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3607 Visual::Base imageVisual = factory.CreateVisual(
3609 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3610 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3612 Dali::Property::Map visualMap;
3613 imageVisual.CreatePropertyMap(visualMap);
3614 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3617 DALI_TEST_CHECK(value);
3618 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3621 Visual::Base imageVisual = factory.CreateVisual(
3623 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3624 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3625 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3627 Dali::Property::Map visualMap;
3628 imageVisual.CreatePropertyMap(visualMap);
3629 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3632 DALI_TEST_CHECK(value);
3633 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3636 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3638 Visual::Base imageVisual = factory.CreateVisual(
3640 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3641 .Add(ImageVisual::Property::URL, "something.json"));
3643 Dali::Property::Map visualMap;
3644 imageVisual.CreatePropertyMap(visualMap);
3645 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3648 DALI_TEST_CHECK(value);
3649 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3652 Visual::Base imageVisual = factory.CreateVisual(
3654 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3655 .Add(ImageVisual::Property::URL, "something.json")
3656 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3658 Dali::Property::Map visualMap;
3659 imageVisual.CreatePropertyMap(visualMap);
3660 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3663 DALI_TEST_CHECK(value);
3664 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3667 // text visual ( premultiplied alpha by default is true, and cannot change value )
3669 Visual::Base textVisual = factory.CreateVisual(
3671 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3672 .Add(TextVisual::Property::TEXT, "Text"));
3674 Dali::Property::Map visualMap;
3675 textVisual.CreatePropertyMap(visualMap);
3676 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3679 DALI_TEST_CHECK(value);
3680 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3683 Visual::Base textVisual = factory.CreateVisual(
3685 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3686 .Add(TextVisual::Property::TEXT, "Text")
3687 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3689 Dali::Property::Map visualMap;
3690 textVisual.CreatePropertyMap(visualMap);
3691 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3694 DALI_TEST_CHECK(value);
3695 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3698 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3700 Visual::Base gradientVisual = factory.CreateVisual(
3702 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3703 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3704 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3705 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3707 Dali::Property::Map visualMap;
3708 gradientVisual.CreatePropertyMap(visualMap);
3709 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3712 DALI_TEST_CHECK(value);
3713 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3716 Visual::Base gradientVisual = factory.CreateVisual(
3718 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3719 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3720 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3721 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3722 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3724 Dali::Property::Map visualMap;
3725 gradientVisual.CreatePropertyMap(visualMap);
3726 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3729 DALI_TEST_CHECK(value);
3730 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3733 // color visual ( premultiplied alpha by default is false, and cannot change value )
3735 Visual::Base colorVisual = factory.CreateVisual(
3737 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3738 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3740 Dali::Property::Map visualMap;
3741 colorVisual.CreatePropertyMap(visualMap);
3742 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3745 DALI_TEST_CHECK(value);
3746 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3749 Visual::Base colorVisual = factory.CreateVisual(
3751 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3752 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3753 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3755 Dali::Property::Map visualMap;
3756 colorVisual.CreatePropertyMap(visualMap);
3757 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3760 DALI_TEST_CHECK(value);
3761 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3767 int UtcDaliRegisterVisualOrder(void)
3769 ToolkitTestApplication application;
3770 tet_infoline("Register Visual Order");
3772 DummyControl dummyControl = DummyControl::New(true);
3773 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3775 VisualFactory factory = VisualFactory::Get();
3776 Property::Map propertyMap;
3777 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3778 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3780 tet_infoline("Register visual, should have depth index of 0.0f");
3781 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3782 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3783 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3785 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3787 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3788 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3789 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3791 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3792 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3793 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3795 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3796 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3797 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3799 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed, and be clampled");
3800 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3801 labelVisual.SetDepthIndex(static_cast<int>(Toolkit::DepthIndex::MINIMUM_DEPTH_INDEX) - 100);
3802 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3803 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), static_cast<int>(Toolkit::DepthIndex::MINIMUM_DEPTH_INDEX), TEST_LOCATION);
3805 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3806 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3807 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3808 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3809 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3810 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3812 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured, and be clampled");
3813 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3814 anotherTestVisual2Replacement.SetDepthIndex(static_cast<int>(Toolkit::DepthIndex::MAXIMUM_DEPTH_INDEX) + 100);
3815 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3816 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), static_cast<int>(Toolkit::DepthIndex::MAXIMUM_DEPTH_INDEX), TEST_LOCATION);
3818 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3819 application.GetScene().Add(dummyControl);
3824 int UtcDaliRegisterVisualOrder02(void)
3826 ToolkitTestApplication application;
3827 tet_infoline("Register Visual Order with Background Set");
3829 DummyControl dummyControl = DummyControl::New(true);
3830 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3832 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
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_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3841 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3843 const int TEST_VISUAL_1_DEPTH_INDEX = static_cast<int>(Toolkit::DepthIndex::CONTENT);
3844 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3845 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3846 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3847 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3849 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3850 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3851 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3852 DALI_TEST_GREATER(testVisual2.GetDepthIndex(), testVisual1.GetDepthIndex(), TEST_LOCATION);
3854 const int TEST_VISUAL_2_DEPTH_INDEX = testVisual2.GetDepthIndex();
3856 tet_printf("Register other visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_2_DEPTH_INDEX);
3857 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3858 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, testVisual3, Toolkit::DepthIndex::AUTO_INDEX);
3859 DALI_TEST_GREATER(testVisual3.GetDepthIndex(), testVisual2.GetDepthIndex(), TEST_LOCATION);
3861 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3862 application.GetScene().Add(dummyControl);
3867 int UtcDaliRegisterVisualWithDepthIndex(void)
3869 ToolkitTestApplication application;
3870 tet_infoline("Register a Visual With Depth Index");
3872 DummyControl dummyControl = DummyControl::New(true);
3873 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3875 VisualFactory factory = VisualFactory::Get();
3876 Property::Map propertyMap;
3877 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3878 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3880 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3881 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3882 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3883 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3884 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3886 tet_infoline("Register another visual with a depth index and it disabled");
3887 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3888 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3889 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3890 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3892 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3893 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3894 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3895 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3896 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3898 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3899 application.GetScene().Add(dummyControl);
3904 int UtcDaliSvgVisualCustomShader(void)
3906 ToolkitTestApplication application;
3907 tet_infoline("SvgVisual with custom shader");
3909 VisualFactory factory = VisualFactory::Get();
3910 Property::Map properties;
3911 Property::Map shader;
3912 const std::string vertexShader = "Foobar";
3913 const std::string fragmentShader = "Foobar";
3914 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3915 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3917 properties[Visual::Property::TYPE] = Visual::IMAGE;
3918 properties[Visual::Property::SHADER] = shader;
3919 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3921 Visual::Base visual = factory.CreateVisual(properties);
3923 // trigger creation through setting on stage
3924 DummyControl dummy = DummyControl::New(true);
3925 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3926 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3928 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3929 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3930 application.GetScene().Add(dummy);
3932 application.SendNotification();
3933 application.Render();
3935 // Wait for loading & rasterization
3936 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3938 Renderer renderer = dummy.GetRendererAt(0);
3939 Shader shader2 = renderer.GetShader();
3940 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3941 Property::Map* map = value.GetMap();
3942 DALI_TEST_CHECK(map);
3944 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3945 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3947 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3948 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3953 int UtcDaliVisualRoundedCorner(void)
3955 tet_infoline("UtcDaliVisualRoundedCorner");
3957 static std::vector<UniformData> customUniforms =
3959 UniformData("cornerRadius", Property::Type::VECTOR4),
3960 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3965 ToolkitTestApplication application;
3966 TestGraphicsController& graphics = application.GetGraphicsController();
3967 graphics.AddCustomUniforms(customUniforms);
3969 VisualFactory factory = VisualFactory::Get();
3970 Property::Map properties;
3971 float cornerRadius = 30.0f;
3973 properties[Visual::Property::TYPE] = Visual::IMAGE;
3974 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3975 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3977 Visual::Base visual = factory.CreateVisual(properties);
3979 // trigger creation through setting on stage
3980 DummyControl dummy = DummyControl::New(true);
3981 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3982 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3984 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3985 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3986 application.GetScene().Add(dummy);
3988 application.SendNotification();
3989 application.Render();
3991 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3993 application.SendNotification();
3994 application.Render();
3996 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3997 // Default corner radius policy is absolute.
3998 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4003 ToolkitTestApplication application;
4004 TestGraphicsController& graphics = application.GetGraphicsController();
4005 graphics.AddCustomUniforms(customUniforms);
4007 VisualFactory factory = VisualFactory::Get();
4008 Property::Map properties;
4009 float cornerRadius = 30.0f;
4011 properties[Visual::Property::TYPE] = Visual::COLOR;
4012 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4013 properties["cornerRadius"] = cornerRadius;
4014 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4016 Visual::Base visual = factory.CreateVisual(properties);
4018 // trigger creation through setting on stage
4019 DummyControl dummy = DummyControl::New(true);
4020 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4021 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4023 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4024 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4025 application.GetScene().Add(dummy);
4027 application.SendNotification();
4028 application.Render();
4030 application.SendNotification();
4031 application.Render();
4033 // Currently test with multiple program doesn't work well. will fix another day
4034 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4035 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4040 ToolkitTestApplication application;
4041 TestGraphicsController& graphics = application.GetGraphicsController();
4042 graphics.AddCustomUniforms(customUniforms);
4044 VisualFactory factory = VisualFactory::Get();
4045 Property::Map properties;
4046 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
4048 properties[Visual::Property::TYPE] = Visual::COLOR;
4049 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4050 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4051 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4053 Visual::Base visual = factory.CreateVisual(properties);
4055 // trigger creation through setting on stage
4056 DummyControl dummy = DummyControl::New(true);
4057 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4058 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4060 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4061 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4062 application.GetScene().Add(dummy);
4064 application.SendNotification();
4065 application.Render();
4067 application.SendNotification();
4068 application.Render();
4070 // Currently test with multiple program doesn't work well. will fix another day
4071 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4072 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4075 // color visual 3 - invalid value
4077 ToolkitTestApplication application;
4078 TestGraphicsController& graphics = application.GetGraphicsController();
4079 graphics.AddCustomUniforms(customUniforms);
4081 VisualFactory factory = VisualFactory::Get();
4082 Property::Map properties;
4083 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
4085 properties[Visual::Property::TYPE] = Visual::COLOR;
4086 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4087 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4088 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
4090 Visual::Base visual = factory.CreateVisual(properties);
4092 // trigger creation through setting on stage
4093 DummyControl dummy = DummyControl::New(true);
4094 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4095 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4097 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4098 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4099 application.GetScene().Add(dummy);
4101 application.SendNotification();
4102 application.Render();
4104 application.SendNotification();
4105 application.Render();
4107 // Currently test with multiple program doesn't work well. will fix another day
4108 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4109 // Default corner radius policy is absolute.
4110 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4115 ToolkitTestApplication application;
4116 TestGraphicsController& graphics = application.GetGraphicsController();
4117 graphics.AddCustomUniforms(customUniforms);
4119 VisualFactory factory = VisualFactory::Get();
4120 Property::Map properties;
4121 float cornerRadius = 30.0f;
4123 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4124 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4125 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4126 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4127 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4128 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4130 Property::Array stopOffsets;
4131 stopOffsets.PushBack(0.0f);
4132 stopOffsets.PushBack(0.6f);
4133 stopOffsets.PushBack(1.0f);
4134 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4136 Property::Array stopColors;
4137 stopColors.PushBack(Color::RED);
4138 stopColors.PushBack(Color::YELLOW);
4139 stopColors.PushBack(Color::GREEN);
4140 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4142 Visual::Base visual = factory.CreateVisual(properties);
4144 // trigger creation through setting on stage
4145 DummyControl dummy = DummyControl::New(true);
4146 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4147 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4149 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4150 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4151 application.GetScene().Add(dummy);
4153 application.SendNotification();
4154 application.Render();
4156 application.SendNotification();
4157 application.Render();
4159 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4160 // Default corner radius policy is absolute.
4161 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4164 // animated image visual
4166 ToolkitTestApplication application;
4167 TestGraphicsController& graphics = application.GetGraphicsController();
4168 graphics.AddCustomUniforms(customUniforms);
4170 VisualFactory factory = VisualFactory::Get();
4171 Property::Map properties;
4172 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4174 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4175 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4176 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4177 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4178 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4180 Visual::Base visual = factory.CreateVisual(properties);
4182 // trigger creation through setting on stage
4183 DummyControl dummy = DummyControl::New(true);
4184 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4185 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4187 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4188 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4189 application.GetScene().Add(dummy);
4191 application.SendNotification();
4192 application.Render();
4194 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4196 application.SendNotification();
4197 application.Render();
4199 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4200 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4203 // vector image visual
4205 ToolkitTestApplication application;
4206 TestGraphicsController& graphics = application.GetGraphicsController();
4207 graphics.AddCustomUniforms(customUniforms);
4209 VisualFactory factory = VisualFactory::Get();
4210 Property::Map properties;
4211 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4213 properties[Visual::Property::TYPE] = Visual::SVG;
4214 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4215 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4217 Visual::Base visual = factory.CreateVisual(properties);
4219 // trigger creation through setting on stage
4220 DummyControl dummy = DummyControl::New(true);
4221 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4222 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4224 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4225 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4226 application.GetScene().Add(dummy);
4228 application.SendNotification();
4229 application.Render();
4231 // Wait for loading & rasterization
4232 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4234 application.SendNotification();
4235 application.Render();
4237 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4238 // Default corner radius policy is absolute.
4239 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4242 // animated vector image visual
4244 ToolkitTestApplication application;
4245 TestGraphicsController& graphics = application.GetGraphicsController();
4246 graphics.AddCustomUniforms(customUniforms);
4248 VisualFactory factory = VisualFactory::Get();
4249 Property::Map properties;
4250 float cornerRadius = 1.3f;
4252 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4253 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4254 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4255 properties["cornerRadius"] = cornerRadius;
4256 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4257 properties["synchronousLoading"] = false;
4259 Visual::Base visual = factory.CreateVisual(properties);
4261 // trigger creation through setting on stage
4262 DummyControl dummy = DummyControl::New(true);
4263 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4264 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4266 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4267 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4268 application.GetScene().Add(dummy);
4270 application.SendNotification();
4271 application.Render();
4273 // Trigger count is 2 - load & render a frame
4274 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4276 application.SendNotification();
4277 application.Render();
4279 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4280 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4286 int UtcDaliVisualBorderline(void)
4288 tet_infoline("UtcDaliVisualBorderline");
4290 static std::vector<UniformData> customUniforms =
4292 UniformData("cornerRadius", Property::Type::VECTOR4),
4293 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4294 UniformData("borderlineWidth", Property::Type::FLOAT),
4295 UniformData("borderlineColor", Property::Type::VECTOR4),
4296 UniformData("borderlineOffset", Property::Type::FLOAT),
4301 ToolkitTestApplication application;
4302 TestGraphicsController& graphics = application.GetGraphicsController();
4303 graphics.AddCustomUniforms(customUniforms);
4305 VisualFactory factory = VisualFactory::Get();
4306 Property::Map properties;
4307 float cornerRadius = 5.0f;
4308 float borderlineWidth = 30.0f;
4309 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4310 float borderlineOffset = 1.0f;
4312 properties[Visual::Property::TYPE] = Visual::IMAGE;
4313 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4314 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4315 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4316 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4317 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4319 Visual::Base visual = factory.CreateVisual(properties);
4321 // trigger creation through setting on stage
4322 DummyControl dummy = DummyControl::New(true);
4323 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4324 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4326 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4327 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4328 application.GetScene().Add(dummy);
4330 application.SendNotification();
4331 application.Render();
4333 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4335 application.SendNotification();
4336 application.Render();
4338 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4339 // Default corner radius policy is absolute.
4340 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4341 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4342 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4343 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4348 ToolkitTestApplication application;
4349 TestGraphicsController& graphics = application.GetGraphicsController();
4350 graphics.AddCustomUniforms(customUniforms);
4352 VisualFactory factory = VisualFactory::Get();
4353 Property::Map properties;
4354 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4355 float borderlineWidth = 30.0f;
4356 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4357 float borderlineOffset = -0.4f;
4359 properties[Visual::Property::TYPE] = Visual::COLOR;
4360 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4361 properties["cornerRadius"] = cornerRadius;
4362 properties["borderlineWidth"] = borderlineWidth;
4363 properties["borderlineColor"] = borderlineColor;
4364 properties["borderlineOffset"] = borderlineOffset;
4366 Visual::Base visual = factory.CreateVisual(properties);
4368 // trigger creation through setting on stage
4369 DummyControl dummy = DummyControl::New(true);
4370 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4371 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4373 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4374 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4375 application.GetScene().Add(dummy);
4377 application.SendNotification();
4378 application.Render();
4380 application.SendNotification();
4381 application.Render();
4383 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4384 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4385 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4386 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4389 // color visual 2, default color, default offset
4391 ToolkitTestApplication application;
4392 TestGraphicsController& graphics = application.GetGraphicsController();
4393 graphics.AddCustomUniforms(customUniforms);
4395 VisualFactory factory = VisualFactory::Get();
4396 Property::Map properties;
4397 float borderlineWidth = 30.0f;
4399 properties[Visual::Property::TYPE] = Visual::COLOR;
4400 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4401 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4403 Visual::Base visual = factory.CreateVisual(properties);
4405 // trigger creation through setting on stage
4406 DummyControl dummy = DummyControl::New(true);
4407 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4408 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4410 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4411 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4412 application.GetScene().Add(dummy);
4414 application.SendNotification();
4415 application.Render();
4417 application.SendNotification();
4418 application.Render();
4420 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4421 // Default borderline color is BLACK.
4422 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4423 // Default borderline offset is 0.0f.
4424 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4427 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
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 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4437 float borderlineOffset = 37.4f;
4439 properties[Visual::Property::TYPE] = Visual::COLOR;
4440 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4441 properties["borderlineWidth"] = borderlineWidth;
4442 properties["borderlineColor"] = borderlineColor;
4443 properties["borderlineOffset"] = borderlineOffset;
4445 Visual::Base visual = factory.CreateVisual(properties);
4447 // trigger creation through setting on stage
4448 DummyControl dummy = DummyControl::New(true);
4449 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4450 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4452 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4453 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4454 application.GetScene().Add(dummy);
4456 application.SendNotification();
4457 application.Render();
4459 application.SendNotification();
4460 application.Render();
4462 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4463 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4464 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4465 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4470 ToolkitTestApplication application;
4471 TestGraphicsController& graphics = application.GetGraphicsController();
4472 graphics.AddCustomUniforms(customUniforms);
4474 VisualFactory factory = VisualFactory::Get();
4475 Property::Map properties;
4476 float borderlineWidth = 30.0f;
4477 float cornerRadius = 70.0f;
4479 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4480 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4481 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4482 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4483 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4484 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4485 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4487 Property::Array stopOffsets;
4488 stopOffsets.PushBack(0.0f);
4489 stopOffsets.PushBack(0.6f);
4490 stopOffsets.PushBack(1.0f);
4491 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4493 Property::Array stopColors;
4494 stopColors.PushBack(Color::RED);
4495 stopColors.PushBack(Color::YELLOW);
4496 stopColors.PushBack(Color::GREEN);
4497 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4499 Visual::Base visual = factory.CreateVisual(properties);
4501 // trigger creation through setting on stage
4502 DummyControl dummy = DummyControl::New(true);
4503 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4504 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4506 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4507 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4508 application.GetScene().Add(dummy);
4510 application.SendNotification();
4511 application.Render();
4513 application.SendNotification();
4514 application.Render();
4516 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4517 // Default corner radius policy is absolute.
4518 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4519 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4520 // Default borderline color is BLACK.
4521 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4522 // Default borderline offset is 0.0f.
4523 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4526 // animated image visual
4528 ToolkitTestApplication application;
4529 TestGraphicsController& graphics = application.GetGraphicsController();
4530 graphics.AddCustomUniforms(customUniforms);
4532 VisualFactory factory = VisualFactory::Get();
4533 Property::Map properties;
4534 float borderlineWidth = 24.0f;
4535 float borderlineOffset = -1.0f;
4537 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4538 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4539 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4540 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4541 properties["borderlineOffset"] = borderlineOffset;
4543 Visual::Base visual = factory.CreateVisual(properties);
4545 // trigger creation through setting on stage
4546 DummyControl dummy = DummyControl::New(true);
4547 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4548 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4550 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4551 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4552 application.GetScene().Add(dummy);
4554 application.SendNotification();
4555 application.Render();
4557 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4559 application.SendNotification();
4560 application.Render();
4562 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4563 // Default borderline color is BLACK.
4564 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4565 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4568 // vector image visual
4570 ToolkitTestApplication application;
4571 TestGraphicsController& graphics = application.GetGraphicsController();
4572 graphics.AddCustomUniforms(customUniforms);
4574 VisualFactory factory = VisualFactory::Get();
4575 Property::Map properties;
4576 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4577 float borderlineWidth = 27.0f;
4578 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4580 properties[Visual::Property::TYPE] = Visual::SVG;
4581 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4582 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4583 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4584 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4586 Visual::Base visual = factory.CreateVisual(properties);
4588 // trigger creation through setting on stage
4589 DummyControl dummy = DummyControl::New(true);
4590 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4591 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4593 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4594 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4595 application.GetScene().Add(dummy);
4597 application.SendNotification();
4598 application.Render();
4600 // Wait for loading & rasterization
4601 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4603 application.SendNotification();
4604 application.Render();
4606 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4607 // Default corner radius policy is absolute.
4608 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4609 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4610 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4611 // Default borderline offset is 0.0.
4612 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4615 // animated vector image visual
4617 ToolkitTestApplication application;
4618 TestGraphicsController& graphics = application.GetGraphicsController();
4619 graphics.AddCustomUniforms(customUniforms);
4621 VisualFactory factory = VisualFactory::Get();
4622 Property::Map properties;
4623 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4624 float borderlineWidth = 13.0f;
4625 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4626 float borderlineOffset = 13.0f;
4628 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4629 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4630 properties["cornerRadius"] = cornerRadius;
4631 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4632 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4633 properties["borderlineColor"] = borderlineColor;
4634 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4635 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = false;
4637 Visual::Base visual = factory.CreateVisual(properties);
4639 // trigger creation through setting on stage
4640 DummyControl dummy = DummyControl::New(true);
4641 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4642 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4644 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4645 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4646 application.GetScene().Add(dummy);
4648 application.SendNotification();
4649 application.Render();
4651 // Trigger count is 2 - load & render a frame
4652 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4654 application.SendNotification();
4655 application.Render();
4657 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4658 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4659 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4660 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4661 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4667 int UtcDaliVisualBorderlineBlendModeTest(void)
4669 ToolkitTestApplication application;
4670 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4671 VisualFactory factory = VisualFactory::Get();
4673 // Case 1 : Test which doesn't support borderline feature.
4675 tet_printf("Test Unsupported visual type\n");
4676 Property::Map propertyMap;
4677 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4678 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4679 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4680 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4682 DummyControl actor = DummyControl::New(true);
4683 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4684 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4685 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4686 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4687 application.GetScene().Add(actor);
4689 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4691 Renderer renderer = actor.GetRendererAt(0);
4693 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4694 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4695 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4697 application.GetScene().Remove(actor);
4700 // Case 2 : Test which support borderline feature.
4702 tet_printf("Test normal case\n");
4703 Property::Map propertyMap;
4704 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4705 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4706 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4707 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4709 DummyControl actor = DummyControl::New(true);
4710 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4711 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4712 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4713 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4714 application.GetScene().Add(actor);
4716 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4718 Renderer renderer = actor.GetRendererAt(0);
4720 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4721 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4722 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4724 application.GetScene().Remove(actor);
4727 // Case 3 : Test which animated borderline.
4729 tet_printf("Test borderline animate case\n");
4730 Property::Map propertyMap;
4731 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4732 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4733 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4735 DummyControl actor = DummyControl::New(true);
4736 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4737 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4738 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4739 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4740 application.GetScene().Add(actor);
4742 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4744 Renderer renderer = actor.GetRendererAt(0);
4746 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4747 // BlendMode is AUTO.
4748 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4750 Animation animation = Animation::New(0.1f);
4751 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4754 application.SendNotification();
4755 application.Render();
4756 application.Render(101u); // End of animation
4758 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4759 // BlendMode is ON_WITHOUT_CULL.
4760 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4762 Animation revanimation = Animation::New(0.1f);
4763 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4764 revanimation.Play();
4766 application.SendNotification();
4767 application.Render();
4768 application.Render(101u); // End of animation
4770 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4771 // BlendMode is still ON_WITHOUT_CULL.
4772 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4774 application.GetScene().Remove(actor);
4777 // Case 4 : Test which animated corner radius occur.
4779 tet_printf("Test borderline animate case\n");
4780 Property::Map propertyMap;
4781 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4782 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4783 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4784 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4786 DummyControl actor = DummyControl::New(true);
4787 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4788 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4789 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4790 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4791 application.GetScene().Add(actor);
4793 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4795 Renderer renderer = actor.GetRendererAt(0);
4797 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4798 // BlendMode is ON_WITHOUT_CULL.
4799 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4801 Animation animation = Animation::New(0.1f);
4802 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4805 application.SendNotification();
4806 application.Render();
4807 application.Render(101u); // End of animation
4809 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4810 // BlendMode is ON_WITHOUT_CULL.
4811 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4813 application.GetScene().Remove(actor);
4819 int UtcDaliVisualBorderlineColorAnimateTest(void)
4821 ToolkitTestApplication application;
4822 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4824 TestGraphicsController& graphics = application.GetGraphicsController();
4825 static std::vector<UniformData> customUniforms =
4827 UniformData("mixColor", Property::Type::VECTOR3),
4828 UniformData("cornerRadius", Property::Type::VECTOR4),
4829 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4830 UniformData("borderlineWidth", Property::Type::FLOAT),
4831 UniformData("borderlineColor", Property::Type::VECTOR4),
4832 UniformData("borderlineOffset", Property::Type::FLOAT),
4834 graphics.AddCustomUniforms(customUniforms);
4837 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4838 const float INITIAL_MIX_OPACITY(0.5f);
4839 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4840 const float INITIAL_ACTOR_OPACITY(1.0f);
4841 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4842 const float TARGET_MIX_OPACITY(0.8f);
4843 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4844 const float TARGET_ACTOR_OPACITY(0.5f);
4846 VisualFactory factory = VisualFactory::Get();
4847 Property::Map propertyMap;
4848 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4849 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4850 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4851 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4852 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4853 Visual::Base visual = factory.CreateVisual(propertyMap);
4855 DummyControl actor = DummyControl::New(true);
4856 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4857 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4858 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4859 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4860 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4861 application.GetScene().Add(actor);
4863 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4865 Animation animation = Animation::New(4.0f);
4866 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4867 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4868 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4869 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4872 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4874 application.SendNotification();
4875 application.Render(0);
4876 application.Render(2000u); // halfway point
4877 application.SendNotification();
4879 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4880 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4881 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4882 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4883 halfwayMixOpacity *= halfwayActorOpacity;
4884 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4885 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4886 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4887 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4889 application.Render(2001u); // go past end
4890 application.SendNotification(); // Trigger signals
4892 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4893 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4894 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4895 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4896 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4904 int UtcDaliColorVisualBlurRadius(void)
4906 ToolkitTestApplication application;
4907 tet_infoline("UtcDaliColorVisualBlurRadius");
4909 static std::vector<UniformData> customUniforms =
4911 UniformData("blurRadius", Property::Type::FLOAT),
4914 TestGraphicsController& graphics = application.GetGraphicsController();
4915 graphics.AddCustomUniforms(customUniforms);
4917 VisualFactory factory = VisualFactory::Get();
4918 Property::Map properties;
4919 float blurRadius = 20.0f;
4921 properties[Visual::Property::TYPE] = Visual::COLOR;
4922 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4923 properties["blurRadius"] = blurRadius;
4925 Visual::Base visual = factory.CreateVisual(properties);
4927 // trigger creation through setting on stage
4928 DummyControl dummy = DummyControl::New(true);
4929 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4930 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4932 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4933 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4934 application.GetScene().Add(dummy);
4936 application.SendNotification();
4937 application.Render();
4939 application.SendNotification();
4940 application.Render();
4942 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4947 int UtcDaliVisualGetType(void)
4949 ToolkitTestApplication application;
4950 tet_infoline("UtcDaliVisualGetType");
4952 VisualFactory factory = VisualFactory::Get();
4955 Property::Map properties;
4956 properties[Visual::Property::TYPE] = Visual::BORDER;
4957 Visual::Base visual = factory.CreateVisual(properties);
4959 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4963 Property::Map properties;
4964 properties[Visual::Property::TYPE] = Visual::COLOR;
4965 Visual::Base visual = factory.CreateVisual(properties);
4967 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4971 Property::Map properties;
4972 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4973 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4974 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4975 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4976 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4977 Property::Array stopColors;
4978 stopColors.PushBack(Color::RED);
4979 stopColors.PushBack(Color::GREEN);
4980 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4981 Visual::Base visual = factory.CreateVisual(properties);
4983 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4987 Property::Map properties;
4988 properties[Visual::Property::TYPE] = Visual::IMAGE;
4989 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4990 Visual::Base visual = factory.CreateVisual(properties);
4992 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4996 Property::Map properties;
4997 properties[Visual::Property::TYPE] = Visual::MESH;
4998 Visual::Base visual = factory.CreateVisual(properties);
5000 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
5004 Property::Map properties;
5005 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
5006 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
5007 Visual::Base visual = factory.CreateVisual(properties);
5009 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
5013 Property::Map properties;
5014 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
5015 Visual::Base visual = factory.CreateVisual(properties);
5017 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
5021 Property::Map properties;
5022 properties[Visual::Property::TYPE] = Visual::TEXT;
5023 Visual::Base visual = factory.CreateVisual(properties);
5025 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
5029 Property::Map properties;
5030 properties[Visual::Property::TYPE] = Visual::N_PATCH;
5031 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
5032 Visual::Base visual = factory.CreateVisual(properties);
5034 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
5038 Property::Map properties;
5039 properties[Visual::Property::TYPE] = Visual::SVG;
5040 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
5041 Visual::Base visual = factory.CreateVisual(properties);
5043 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
5047 Property::Map properties;
5048 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
5049 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
5050 Visual::Base visual = factory.CreateVisual(properties);
5052 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
5056 Property::Map properties;
5057 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
5058 Visual::Base visual = factory.CreateVisual(properties);
5060 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
5064 Property::Map properties;
5065 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
5066 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
5067 Visual::Base visual = factory.CreateVisual(properties);
5069 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
5073 Property::Map properties;
5074 properties[Visual::Property::TYPE] = DevelVisual::ARC;
5075 Visual::Base visual = factory.CreateVisual(properties);
5077 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
5083 int UtcDaliVisualGetVisualProperty01(void)
5085 ToolkitTestApplication application;
5086 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
5088 static std::vector<UniformData> customUniforms =
5090 UniformData("mixColor", Property::Type::VECTOR3),
5091 UniformData("offset", Property::Type::VECTOR2),
5092 UniformData("size", Property::Type::VECTOR2),
5093 UniformData("cornerRadius", Property::Type::VECTOR4),
5094 UniformData("blurRadius", Property::Type::FLOAT),
5095 UniformData("borderlineWidth", Property::Type::FLOAT),
5096 UniformData("borderlineColor", Property::Type::VECTOR4),
5097 UniformData("borderlineOffset", Property::Type::FLOAT)};
5099 TestGraphicsController& graphics = application.GetGraphicsController();
5100 graphics.AddCustomUniforms(customUniforms);
5102 VisualFactory factory = VisualFactory::Get();
5103 Property::Map propertyMap;
5104 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5105 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
5106 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
5107 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
5108 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
5109 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
5110 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
5111 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
5112 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5114 DummyControl dummyControl = DummyControl::New(true);
5115 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5116 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5117 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5118 application.GetScene().Add(dummyControl);
5120 application.SendNotification();
5121 application.Render();
5123 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5124 Vector2 targetOffset(0.05f, 0.05f);
5125 Vector2 targetSize(1.1f, 1.1f);
5126 float targetOpacity = 0.5f;
5127 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
5128 float targetBlurRadius = 10.0f;
5129 float targetBorderlineWidth = 25.0f;
5130 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
5131 float targetBorderlineOffset = -1.0f;
5133 Animation animation = Animation::New(1.0f);
5134 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
5135 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5136 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5137 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5138 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5139 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5140 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5141 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5142 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5145 application.SendNotification();
5146 application.Render();
5147 application.Render(1001u); // End of animation
5149 Property::Map resultMap;
5150 colorVisual.CreatePropertyMap(resultMap);
5152 // Test property values: they should be updated
5153 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5154 DALI_TEST_CHECK(colorValue);
5155 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5157 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5158 Dali::Property::Map* transformMap = transformValue->GetMap();
5159 DALI_TEST_CHECK(transformMap);
5161 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5162 DALI_TEST_CHECK(offsetValue);
5163 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5165 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5166 DALI_TEST_CHECK(sizeValue);
5167 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5169 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5170 DALI_TEST_CHECK(cornerRadiusValue);
5171 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5173 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5174 DALI_TEST_CHECK(blurRadiusValue);
5175 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5177 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5178 DALI_TEST_CHECK(borderlineWidthValue);
5179 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5181 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5182 DALI_TEST_CHECK(borderlineColorValue);
5183 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5185 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5186 DALI_TEST_CHECK(borderlineOffsetValue);
5187 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5189 // Test uniform values
5190 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5191 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5192 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5193 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5194 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5195 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5196 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5197 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5199 // Test unregistered visual
5200 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5201 DALI_TEST_CHECK(!property3.object);
5202 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5207 int UtcDaliVisualGetVisualProperty02(void)
5209 ToolkitTestApplication application;
5210 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5212 static std::vector<UniformData> customUniforms =
5214 UniformData("mixColor", Property::Type::VECTOR3),
5215 UniformData("offset", Property::Type::VECTOR2),
5216 UniformData("size", Property::Type::VECTOR2),
5217 UniformData("cornerRadius", Property::Type::VECTOR4),
5218 UniformData("borderlineWidth", Property::Type::FLOAT),
5219 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5220 UniformData("borderlineOffset", Property::Type::FLOAT),
5221 UniformData("blurRadius", Property::Type::FLOAT),
5224 TestGraphicsController& graphics = application.GetGraphicsController();
5225 graphics.AddCustomUniforms(customUniforms);
5227 VisualFactory factory = VisualFactory::Get();
5228 Property::Map propertyMap;
5229 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5230 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5232 DummyControl dummyControl = DummyControl::New(true);
5233 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5234 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5235 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5236 application.GetScene().Add(dummyControl);
5238 application.SendNotification();
5239 application.Render();
5241 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5242 Vector2 targetOffset(0.05f, 0.05f);
5243 Vector2 targetSize(1.1f, 1.1f);
5244 float targetOpacity = 0.5f;
5245 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5246 float targetBorderlineWidth = 77.7f;
5247 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5248 float targetBorderlineOffset = 1.0f;
5249 float targetBlurRadius = 10.0f;
5251 // Should work when the properties are not set before
5252 Animation animation = Animation::New(1.0f);
5253 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5254 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5255 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5256 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5257 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5258 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5259 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5260 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5261 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5264 application.SendNotification();
5265 application.Render();
5266 application.Render(1001u); // End of animation
5268 Property::Map resultMap;
5269 colorVisual.CreatePropertyMap(resultMap);
5271 // Test property values: they should be updated
5272 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5273 DALI_TEST_CHECK(colorValue);
5274 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5276 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5277 Dali::Property::Map* transformMap = transformValue->GetMap();
5278 DALI_TEST_CHECK(transformMap);
5280 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5281 DALI_TEST_CHECK(offsetValue);
5282 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5284 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5285 DALI_TEST_CHECK(sizeValue);
5286 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5288 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5289 DALI_TEST_CHECK(cornerRadiusValue);
5290 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5292 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5293 DALI_TEST_CHECK(borderlineWidthValue);
5294 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5296 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5297 DALI_TEST_CHECK(borderlineColorValue);
5298 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5300 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5301 DALI_TEST_CHECK(borderlineOffsetValue);
5302 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5304 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5305 DALI_TEST_CHECK(blurRadiusValue);
5306 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5308 // Test uniform values
5309 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5310 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5311 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5312 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5313 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5318 int UtcDaliVisualGetVisualProperty03(void)
5320 ToolkitTestApplication application;
5321 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5323 static std::vector<UniformData> customUniforms =
5325 UniformData("pixelArea", Property::Type::VECTOR4),
5326 UniformData("cornerRadius", Property::Type::VECTOR4),
5327 UniformData("borderlineWidth", Property::Type::FLOAT),
5328 UniformData("borderlineColor", Property::Type::VECTOR4),
5329 UniformData("borderlineOffset", Property::Type::FLOAT),
5332 TestGraphicsController& graphics = application.GetGraphicsController();
5333 graphics.AddCustomUniforms(customUniforms);
5335 VisualFactory factory = VisualFactory::Get();
5336 Property::Map propertyMap;
5337 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5338 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5340 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5342 DummyControl dummyControl = DummyControl::New(true);
5343 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5344 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5345 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5346 application.GetScene().Add(dummyControl);
5348 // Wait for image loading
5349 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5351 application.SendNotification();
5352 application.Render();
5354 float targetOpacity = 0.5f;
5355 Vector4 targetPixelArea(0.0f, 1.0f, 2.0f, -0.5f);
5356 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5357 float targetBorderlineWidth = 10.0f;
5358 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5359 float targetBorderlineOffset = -1.5f;
5361 Animation animation = Animation::New(1.0f);
5362 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5363 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, ImageVisual::Property::PIXEL_AREA), targetPixelArea);
5364 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5365 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5366 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5367 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5370 application.SendNotification();
5371 application.Render();
5372 application.Render(1001u); // End of animation
5374 Property::Map resultMap;
5375 imageVisual.CreatePropertyMap(resultMap);
5377 // Test property values: they should be updated
5378 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5379 DALI_TEST_CHECK(colorValue);
5380 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5382 Property::Value* pixelAreaValue = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
5383 DALI_TEST_CHECK(pixelAreaValue);
5384 DALI_TEST_EQUALS(pixelAreaValue->Get<Vector4>(), targetPixelArea, TEST_LOCATION);
5386 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5387 DALI_TEST_CHECK(cornerRadiusValue);
5388 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5390 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5391 DALI_TEST_CHECK(borderlineWidthValue);
5392 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5394 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5395 DALI_TEST_CHECK(borderlineColorValue);
5396 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5398 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5399 DALI_TEST_CHECK(borderlineOffsetValue);
5400 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5402 // Test uniform value
5403 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", targetPixelArea), true, TEST_LOCATION);
5404 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5405 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5406 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5407 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5409 // Test non-animatable index, for coverage.
5410 DALI_TEST_EQUALS(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, ImageVisual::Property::URL).propertyIndex, Property::INVALID_INDEX, TEST_LOCATION);
5415 int UtcDaliVisualGetVisualProperty04(void)
5417 ToolkitTestApplication application;
5418 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5420 static std::vector<UniformData> customUniforms =
5422 UniformData("cornerRadius", Property::Type::VECTOR4),
5425 TestGraphicsController& graphics = application.GetGraphicsController();
5426 graphics.AddCustomUniforms(customUniforms);
5428 Vector2 start(-1.f, -1.f);
5429 Vector2 end(1.f, 1.f);
5430 Property::Array stopColors;
5431 stopColors.PushBack(Color::RED);
5432 stopColors.PushBack(Color::GREEN);
5434 VisualFactory factory = VisualFactory::Get();
5435 Property::Map propertyMap;
5436 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5437 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5438 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5439 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5440 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5441 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5442 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5444 DummyControl dummyControl = DummyControl::New(true);
5445 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5446 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5447 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5448 application.GetScene().Add(dummyControl);
5450 application.SendNotification();
5451 application.Render();
5453 float targetOpacity = 0.5f;
5454 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5456 Animation animation = Animation::New(1.0f);
5457 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5458 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5461 application.SendNotification();
5462 application.Render();
5463 application.Render(1001u); // End of animation
5465 Property::Map resultMap;
5466 gradientVisual.CreatePropertyMap(resultMap);
5468 // Test property values: they should be updated
5469 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5470 DALI_TEST_CHECK(colorValue);
5471 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5473 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5474 DALI_TEST_CHECK(cornerRadiusValue);
5475 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5477 // Test uniform value
5478 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5483 int UtcDaliVisualGetVisualProperty05(void)
5485 ToolkitTestApplication application;
5486 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5488 static std::vector<UniformData> customUniforms =
5490 UniformData("cornerRadius", Property::Type::VECTOR4),
5491 UniformData("borderlineWidth", Property::Type::FLOAT),
5492 UniformData("borderlineColor", Property::Type::VECTOR4),
5493 UniformData("borderlineOffset", Property::Type::FLOAT),
5496 TestGraphicsController& graphics = application.GetGraphicsController();
5497 graphics.AddCustomUniforms(customUniforms);
5499 VisualFactory factory = VisualFactory::Get();
5500 Property::Map propertyMap;
5501 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5502 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5504 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5506 DummyControl dummyControl = DummyControl::New(true);
5507 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5508 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5509 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5510 application.GetScene().Add(dummyControl);
5512 application.SendNotification();
5513 application.Render();
5515 // Wait for loading & rasterization
5516 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5518 application.SendNotification();
5519 application.Render();
5521 float targetOpacity = 0.5f;
5522 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5523 float targetBorderlineWidth = 10.0f;
5524 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5525 float targetBorderlineOffset = -1.5f;
5527 Animation animation = Animation::New(1.0f);
5528 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5529 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5530 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5531 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5532 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5535 application.SendNotification();
5536 application.Render();
5537 application.Render(1001u); // End of animation
5539 Property::Map resultMap;
5540 svgVisual.CreatePropertyMap(resultMap);
5542 // Test property values: they should be updated
5543 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5544 DALI_TEST_CHECK(colorValue);
5545 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5547 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5548 DALI_TEST_CHECK(cornerRadiusValue);
5549 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5551 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5552 DALI_TEST_CHECK(borderlineWidthValue);
5553 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5555 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5556 DALI_TEST_CHECK(borderlineColorValue);
5557 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5559 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5560 DALI_TEST_CHECK(borderlineOffsetValue);
5561 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5563 // Currently test with multiple program doesn't work well. will fix another day
5564 // Test uniform value
5565 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5566 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5567 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5568 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5573 int UtcDaliVisualGetVisualProperty06(void)
5575 ToolkitTestApplication application;
5576 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5578 static std::vector<UniformData> customUniforms =
5580 UniformData("cornerRadius", Property::Type::VECTOR4),
5581 UniformData("borderlineWidth", Property::Type::FLOAT),
5582 UniformData("borderlineColor", Property::Type::VECTOR4),
5583 UniformData("borderlineOffset", Property::Type::FLOAT),
5586 TestGraphicsController& graphics = application.GetGraphicsController();
5587 graphics.AddCustomUniforms(customUniforms);
5589 VisualFactory factory = VisualFactory::Get();
5590 Property::Map propertyMap;
5591 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5592 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5594 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5596 DummyControl dummyControl = DummyControl::New(true);
5597 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5598 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5599 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5600 application.GetScene().Add(dummyControl);
5602 application.SendNotification();
5603 application.Render();
5605 // Wait for image loading
5606 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5608 application.SendNotification();
5609 application.Render();
5611 float targetOpacity = 0.5f;
5612 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5613 float targetBorderlineWidth = 10.0f;
5614 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5615 float targetBorderlineOffset = -1.5f;
5617 Animation animation = Animation::New(1.0f);
5618 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5619 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5620 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5621 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5622 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5625 application.SendNotification();
5626 application.Render();
5627 application.Render(1001u); // End of animation
5629 Property::Map resultMap;
5630 animatedImageVisual.CreatePropertyMap(resultMap);
5632 // Test property values: they should be updated
5633 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5634 DALI_TEST_CHECK(colorValue);
5635 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5637 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5638 DALI_TEST_CHECK(cornerRadiusValue);
5639 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5641 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5642 DALI_TEST_CHECK(borderlineWidthValue);
5643 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5645 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5646 DALI_TEST_CHECK(borderlineColorValue);
5647 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5649 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5650 DALI_TEST_CHECK(borderlineOffsetValue);
5651 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5653 // Currently test with multiple program doesn't work well. will fix another day
5654 // Test uniform value
5655 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5656 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5657 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5658 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5663 int UtcDaliVisualGetVisualProperty07(void)
5665 ToolkitTestApplication application;
5666 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5668 static std::vector<UniformData> customUniforms =
5670 UniformData("cornerRadius", Property::Type::VECTOR4),
5671 UniformData("borderlineWidth", Property::Type::FLOAT),
5672 UniformData("borderlineColor", Property::Type::VECTOR4),
5673 UniformData("borderlineOffset", Property::Type::FLOAT),
5676 TestGraphicsController& graphics = application.GetGraphicsController();
5677 graphics.AddCustomUniforms(customUniforms);
5679 VisualFactory factory = VisualFactory::Get();
5680 Property::Map propertyMap;
5681 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5682 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5683 propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, false);
5685 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5687 DummyControl dummyControl = DummyControl::New(true);
5688 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5689 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5690 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5691 application.GetScene().Add(dummyControl);
5693 application.SendNotification();
5694 application.Render();
5696 // Trigger count is 2 - load & render a frame
5697 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5699 application.SendNotification();
5700 application.Render();
5702 float targetOpacity = 0.5f;
5703 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5704 float targetBorderlineWidth = 10.0f;
5705 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5706 float targetBorderlineOffset = -1.5f;
5708 Animation animation = Animation::New(1.0f);
5709 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5710 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5711 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5712 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5713 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5716 application.SendNotification();
5717 application.Render();
5718 application.Render(1001u); // End of animation
5720 Property::Map resultMap;
5721 animatedVectorVisual.CreatePropertyMap(resultMap);
5723 // Test property values: they should be updated
5724 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5725 DALI_TEST_CHECK(colorValue);
5726 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5728 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5729 DALI_TEST_CHECK(cornerRadiusValue);
5730 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5732 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5733 DALI_TEST_CHECK(borderlineWidthValue);
5734 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5736 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5737 DALI_TEST_CHECK(borderlineColorValue);
5738 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5740 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5741 DALI_TEST_CHECK(borderlineOffsetValue);
5742 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5744 // Currently test with multiple program doesn't work well. will fix another day
5745 // Test uniform value
5746 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5747 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5748 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5749 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5754 int UtcDaliVisualUpdateProperty01(void)
5756 ToolkitTestApplication application;
5757 tet_infoline("UtcDaliVisualUpdateProperty01: Test update property by DoAction. Standard case");
5759 VisualFactory factory = VisualFactory::Get();
5760 Property::Map propertyMap;
5761 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5762 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5763 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5764 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5766 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5768 DummyControl dummyControl = DummyControl::New(true);
5769 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5770 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5771 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5772 application.GetScene().Add(dummyControl);
5774 application.SendNotification();
5775 application.Render();
5777 // Wait for image loading
5778 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5780 application.SendNotification();
5781 application.Render();
5783 Property::Map originalMap;
5784 imageVisual.CreatePropertyMap(originalMap);
5786 float targetOpacity = 0.5f;
5787 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5788 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5789 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5790 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5791 float targetBorderlineWidth = 20.0f;
5792 Vector4 targetBorderlineColor = Color::RED;
5793 float targetBorderlineOffset = 1.0f;
5795 Property::Map targetPropertyMap;
5796 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5797 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5798 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5799 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5800 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5801 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5802 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5803 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5804 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5806 // Update Properties
5807 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5809 Property::Map resultMap;
5810 imageVisual.CreatePropertyMap(resultMap);
5812 // Test property values: they should be updated
5813 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5814 DALI_TEST_CHECK(colorValue);
5815 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5817 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5818 DALI_TEST_CHECK(urlValue);
5819 // NOTE : ImageVisual URL must NOT changed.
5820 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5822 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5823 DALI_TEST_CHECK(preMultipliedValue);
5824 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5826 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5827 DALI_TEST_CHECK(visualFittingModeValue);
5828 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5830 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5831 DALI_TEST_CHECK(cornerRadiusValue);
5832 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5834 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5835 DALI_TEST_CHECK(borderlineWidthValue);
5836 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5838 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5839 DALI_TEST_CHECK(borderlineColorValue);
5840 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5842 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5843 DALI_TEST_CHECK(borderlineOffsetValue);
5844 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5849 int UtcDaliVisualUpdateProperty02(void)
5851 ToolkitTestApplication application;
5852 tet_infoline("UtcDaliVisualUpdateProperty02: Test update property by DoAction. Initialize as zero, and update non-zero case");
5854 Vector4 borderlineColor = Color::BLUE;
5855 float borderlineOffset = 1.0f;
5857 VisualFactory factory = VisualFactory::Get();
5858 Property::Map propertyMap;
5859 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5860 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5861 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5862 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5863 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 0.0f;
5864 propertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5865 propertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5866 propertyMap[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
5867 propertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
5869 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5871 DummyControl dummyControl = DummyControl::New(true);
5872 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5873 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5874 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5875 application.GetScene().Add(dummyControl);
5877 application.SendNotification();
5878 application.Render();
5880 // Wait for image loading
5881 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5883 application.SendNotification();
5884 application.Render();
5886 Property::Map originalMap;
5887 imageVisual.CreatePropertyMap(originalMap);
5889 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5890 float targetBorderlineWidth = 20.0f;
5892 Property::Map targetPropertyMap;
5893 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5894 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5896 // Update Properties
5897 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5899 Property::Map resultMap;
5900 imageVisual.CreatePropertyMap(resultMap);
5902 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5903 DALI_TEST_CHECK(cornerRadiusValue);
5904 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5906 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5907 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5908 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5910 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5911 DALI_TEST_CHECK(borderlineWidthValue);
5912 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5914 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5915 DALI_TEST_CHECK(borderlineColorValue);
5916 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), borderlineColor, TEST_LOCATION);
5918 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5919 DALI_TEST_CHECK(borderlineOffsetValue);
5920 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), borderlineOffset, TEST_LOCATION);
5925 int UtcDaliVisualUpdatePropertyInvalidType(void)
5927 ToolkitTestApplication application;
5928 tet_infoline("UtcDaliVisualUpdatePropertyInvalidType: Test update property by DoAction. But some value is not invalid to update");
5930 VisualFactory factory = VisualFactory::Get();
5931 Property::Map propertyMap;
5932 propertyMap[Visual::Property::TYPE] = Visual::Type::N_PATCH;
5933 propertyMap[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
5935 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5937 DummyControl dummyControl = DummyControl::New(true);
5938 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5939 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5940 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5941 application.GetScene().Add(dummyControl);
5943 application.SendNotification();
5944 application.Render();
5946 // Wait for image loading
5947 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5949 application.SendNotification();
5950 application.Render();
5952 Property::Map originalMap;
5953 imageVisual.CreatePropertyMap(originalMap);
5955 float targetOpacity = 0.5f;
5956 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5957 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5958 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5959 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5960 float targetBorderlineWidth = 20.0f;
5961 Vector4 targetBorderlineColor = Color::RED;
5962 float targetBorderlineOffset = 1.0f;
5964 Property::Map targetPropertyMap;
5965 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5966 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5967 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5968 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5969 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5971 // Properties that N_PATCH visual could not used.
5972 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5973 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5974 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5975 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5977 // Update Properties
5978 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5980 Property::Map resultMap;
5981 imageVisual.CreatePropertyMap(resultMap);
5983 // Test property values: they should be updated
5984 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5985 DALI_TEST_CHECK(colorValue);
5986 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5988 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5989 DALI_TEST_CHECK(urlValue);
5990 // NOTE : NPatchVisual URL must NOT changed.
5991 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_NPATCH_FILE_NAME, TEST_LOCATION);
5993 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5994 DALI_TEST_CHECK(preMultipliedValue);
5995 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5997 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5998 DALI_TEST_CHECK(visualFittingModeValue);
5999 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
6001 // We don't check properties value that N_PATCH visual could not used.
6007 int UtcDaliVisualUpdatePropertyChangeShader01(void)
6009 ToolkitTestApplication application;
6010 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
6012 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6014 VisualFactory factory = VisualFactory::Get();
6015 Property::Map propertyMap;
6017 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6018 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6020 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6022 DummyControl dummyControl = DummyControl::New(true);
6023 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6024 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6025 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6026 application.GetScene().Add(dummyControl);
6028 application.SendNotification();
6029 application.Render();
6031 // Wait for image loading
6032 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6034 application.SendNotification();
6035 application.Render();
6037 TestShaderCodeContainSubstrings(
6040 {"#define IS_REQUIRED_BORDERLINE", false},
6041 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6046 callStack.Enable(true);
6048 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
6050 Property::Map targetPropertyMap;
6051 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6052 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
6054 // Update Properties with CornerRadius
6055 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6057 Property::Map resultMap;
6058 imageVisual.CreatePropertyMap(resultMap);
6060 // Test property values: they should be updated
6061 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6062 DALI_TEST_CHECK(cornerRadiusValue);
6063 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6065 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6066 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6067 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
6069 TestShaderCodeContainSubstrings(
6072 {"#define IS_REQUIRED_BORDERLINE", false},
6073 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6077 // Send shader compile signal
6078 application.SendNotification();
6079 application.Render();
6081 callStack.Enable(false);
6083 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6085 callStack.Enable(true);
6087 float targetBorderlineWidth = 10.0f;
6088 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
6089 float targetBorderlineOffset = -0.3f;
6091 Property::Map targetPropertyMap2;
6092 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6093 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6094 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6095 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6096 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6098 // Update Properties with Borderline
6099 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6101 Property::Map resultMap2;
6102 imageVisual.CreatePropertyMap(resultMap2);
6104 // Test property values: they should be updated
6105 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6106 DALI_TEST_CHECK(cornerRadiusValue);
6107 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6109 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6110 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6111 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6113 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6114 DALI_TEST_CHECK(borderlineWidthValue);
6115 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6117 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6118 DALI_TEST_CHECK(borderlineColorValue);
6119 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6121 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6122 DALI_TEST_CHECK(borderlineOffsetValue);
6123 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6125 TestShaderCodeContainSubstrings(
6128 {"#define IS_REQUIRED_BORDERLINE", true},
6129 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6133 // Send shader compile signal
6134 application.SendNotification();
6135 application.Render();
6137 callStack.Enable(false);
6139 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6141 callStack.Enable(true);
6143 Property::Map targetPropertyMap3;
6144 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6145 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6146 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
6147 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
6148 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
6150 // Update Properties into zero
6151 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
6153 Property::Map resultMap3;
6154 imageVisual.CreatePropertyMap(resultMap3);
6156 // Test property values: they should be updated
6157 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6158 DALI_TEST_CHECK(cornerRadiusValue);
6159 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6161 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6162 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6163 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6165 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6166 DALI_TEST_CHECK(borderlineWidthValue);
6167 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
6169 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6170 DALI_TEST_CHECK(borderlineColorValue);
6171 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6173 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6174 DALI_TEST_CHECK(borderlineOffsetValue);
6175 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
6177 TestShaderCodeContainSubstrings(
6180 {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
6181 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6185 // Send shader compile signal
6186 application.SendNotification();
6187 application.Render();
6189 callStack.Enable(false);
6190 // Shader not changed
6191 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6196 int UtcDaliVisualUpdatePropertyChangeShader02(void)
6198 ToolkitTestApplication application;
6199 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
6201 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6203 VisualFactory factory = VisualFactory::Get();
6204 Property::Map propertyMap;
6206 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6207 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6209 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6211 DummyControl dummyControl = DummyControl::New(true);
6212 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6213 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6214 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6215 application.GetScene().Add(dummyControl);
6217 application.SendNotification();
6218 application.Render();
6220 // Wait for image loading
6221 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6223 application.SendNotification();
6224 application.Render();
6226 TestShaderCodeContainSubstrings(
6229 {"#define IS_REQUIRED_BORDERLINE", false},
6230 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6234 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6236 Property::Map targetPropertyMap;
6237 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6240 callStack.Enable(true);
6242 // Update Properties with CornerRadius
6243 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6245 Property::Map resultMap;
6246 imageVisual.CreatePropertyMap(resultMap);
6248 // Test property values: they should be updated
6249 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6250 DALI_TEST_CHECK(cornerRadiusValue);
6251 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6253 TestShaderCodeContainSubstrings(
6256 {"#define IS_REQUIRED_BORDERLINE", false},
6257 {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
6261 // Send shader compile signal
6262 application.SendNotification();
6263 application.Render();
6265 callStack.Enable(false);
6267 // Shader doesn't changed
6268 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6270 callStack.Enable(true);
6272 float targetBorderlineWidth = 0.0f;
6273 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
6274 float targetBorderlineOffset = -1.0f;
6276 Property::Map targetPropertyMap2;
6277 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6278 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6279 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6281 // Update Properties with Borderline
6282 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6284 Property::Map resultMap2;
6285 imageVisual.CreatePropertyMap(resultMap2);
6287 // Test property values: they should be updated
6288 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6289 DALI_TEST_CHECK(borderlineWidthValue);
6290 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6292 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6293 DALI_TEST_CHECK(borderlineColorValue);
6294 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6296 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6297 DALI_TEST_CHECK(borderlineOffsetValue);
6298 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6300 TestShaderCodeContainSubstrings(
6303 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
6304 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6308 // Send shader compile signal
6309 application.SendNotification();
6310 application.Render();
6312 callStack.Enable(false);
6314 // Shader doesn't changed
6315 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6320 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6322 ToolkitTestApplication application;
6323 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6325 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6327 VisualFactory factory = VisualFactory::Get();
6328 Property::Map propertyMap;
6330 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6331 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6333 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6335 DummyControl dummyControl = DummyControl::New(true);
6336 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6337 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6338 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6339 application.GetScene().Add(dummyControl);
6341 application.SendNotification();
6342 application.Render();
6344 application.SendNotification();
6345 application.Render();
6347 TestShaderCodeContainSubstrings(
6350 {"#define IS_REQUIRED_BLUR", false},
6351 {"#define IS_REQUIRED_BORDERLINE", false},
6352 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6356 float targetBlurRadius = 15.0f;
6357 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6359 Property::Map targetPropertyMap;
6360 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6361 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6362 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6365 callStack.Enable(true);
6367 // Update Properties with CornerRadius
6368 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6370 Property::Map resultMap;
6371 imageVisual.CreatePropertyMap(resultMap);
6373 // Test property values: they should be updated
6374 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6375 DALI_TEST_CHECK(blurRadiusValue);
6376 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6378 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6379 DALI_TEST_CHECK(cornerRadiusValue);
6380 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6382 TestShaderCodeContainSubstrings(
6385 {"#define IS_REQUIRED_BLUR", true},
6386 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6387 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6391 // Send shader compile signal
6392 application.SendNotification();
6393 application.Render();
6395 callStack.Enable(false);
6398 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6400 callStack.Enable(true);
6402 Property::Map targetPropertyMap2;
6403 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6404 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6405 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6407 // Update Properties with CornerRadius
6408 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6410 Property::Map resultMap2;
6411 imageVisual.CreatePropertyMap(resultMap2);
6413 // Test property values: they should be updated
6414 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6415 DALI_TEST_CHECK(blurRadiusValue);
6416 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6418 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6419 DALI_TEST_CHECK(cornerRadiusValue);
6420 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6422 TestShaderCodeContainSubstrings(
6425 {"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
6426 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6427 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6431 // Send shader compile signal
6432 application.SendNotification();
6433 application.Render();
6435 callStack.Enable(false);
6437 // Shader not changed
6438 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6443 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6445 ToolkitTestApplication application;
6446 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6448 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6450 VisualFactory factory = VisualFactory::Get();
6451 Property::Map propertyMap;
6453 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6454 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6455 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6457 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6459 DummyControl dummyControl = DummyControl::New(true);
6460 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6461 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6462 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6463 application.GetScene().Add(dummyControl);
6465 application.SendNotification();
6466 application.Render();
6468 // Wait for image loading
6469 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6471 application.SendNotification();
6472 application.Render();
6474 TestShaderCodeContainSubstrings(
6477 {"#define IS_REQUIRED_BORDERLINE", false},
6478 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6483 callStack.Enable(true);
6485 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6487 Animation animation = Animation::New(1.0f);
6488 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6491 application.SendNotification();
6492 application.Render();
6493 application.Render(1001u); // End of animation
6495 TestShaderCodeContainSubstrings(
6498 {"#define IS_REQUIRED_BORDERLINE", false},
6499 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6503 callStack.Enable(false);
6504 // Shader not changed
6505 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6507 callStack.Enable(true);
6509 float targetBorderlineWidth = 10.0f;
6510 Property::Map targetPropertyMap;
6511 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6513 // Update Properties with CornerRadius
6514 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6516 Property::Map resultMap;
6517 imageVisual.CreatePropertyMap(resultMap);
6519 // Test property values: they should be updated
6520 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6521 DALI_TEST_CHECK(cornerRadiusValue);
6522 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6524 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6525 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6526 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6528 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6529 DALI_TEST_CHECK(borderlineWidthValue);
6530 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6532 TestShaderCodeContainSubstrings(
6535 {"#define IS_REQUIRED_BORDERLINE", true},
6536 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6540 // Send shader compile signal
6541 application.SendNotification();
6542 application.Render();
6544 callStack.Enable(false);
6546 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6551 int UtcDaliVisualUpdatePropertyChangeShader05(void)
6553 ToolkitTestApplication application;
6554 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader05: Test update property under glsl version is under 300");
6556 auto originalShaderVersion = application.GetGlAbstraction().GetShaderLanguageVersion();
6558 // Change the shader language version forcely!
6559 application.GetGlAbstraction().mShaderLanguageVersion = 200;
6563 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6565 VisualFactory factory = VisualFactory::Get();
6566 Property::Map propertyMap;
6568 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6569 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6571 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6573 DummyControl dummyControl = DummyControl::New(true);
6574 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6575 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6576 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6577 application.GetScene().Add(dummyControl);
6579 application.SendNotification();
6580 application.Render();
6582 application.SendNotification();
6583 application.Render();
6585 TestShaderCodeContainSubstrings(
6588 {"#define IS_REQUIRED_BLUR", false},
6589 {"#define IS_REQUIRED_BORDERLINE", false},
6590 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6594 float targetBlurRadius = 15.0f;
6595 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6597 Property::Map targetPropertyMap;
6598 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6599 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6600 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6603 callStack.Enable(true);
6605 // Update Properties with CornerRadius
6606 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6608 Property::Map resultMap;
6609 imageVisual.CreatePropertyMap(resultMap);
6611 // Test property values: they should be updated
6612 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6613 DALI_TEST_CHECK(blurRadiusValue);
6614 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6616 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6617 DALI_TEST_CHECK(cornerRadiusValue);
6618 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6620 TestShaderCodeContainSubstringsForEachShader(
6623 {"#define IS_REQUIRED_BLUR", {true, true}},
6624 {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
6625 {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}},
6626 {"#define SL_VERSION_LOW", {false, true}},
6630 // Send shader compile signal
6631 application.SendNotification();
6632 application.Render();
6634 callStack.Enable(false);
6637 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6639 callStack.Enable(true);
6641 Property::Map targetPropertyMap2;
6642 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6643 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6644 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6646 // Update Properties with CornerRadius
6647 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6649 Property::Map resultMap2;
6650 imageVisual.CreatePropertyMap(resultMap2);
6652 // Test property values: they should be updated
6653 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6654 DALI_TEST_CHECK(blurRadiusValue);
6655 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6657 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6658 DALI_TEST_CHECK(cornerRadiusValue);
6659 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6661 TestShaderCodeContainSubstringsForEachShader(
6664 {"#define IS_REQUIRED_BLUR", {true, true}}, // Note : mAlwaysUsingBlurRadius is true.
6665 {"#define IS_REQUIRED_BORDERLINE", {false, false}}, // Note : We ignore borderline when blur radius occured
6666 {"#define IS_REQUIRED_ROUNDED_CORNER", {true, true}}, // Note : mAlwaysUsingCornerRadius is true.
6667 {"#define SL_VERSION_LOW", {false, true}},
6671 // Send shader compile signal
6672 application.SendNotification();
6673 application.Render();
6675 callStack.Enable(false);
6677 // Shader not changed
6678 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6682 DALI_TEST_CHECK(false);
6685 // Revert shader version. We should revert it even if UTC failed.
6686 application.GetGlAbstraction().mShaderLanguageVersion = originalShaderVersion;
6691 int UtcDaliVisualCutoutPolicyChangeShader01(void)
6693 ToolkitTestApplication application;
6694 tet_infoline("UtcDaliVisualCutoutPolicyChangeShader01: ColorVisual with cutout policy");
6696 static std::vector<UniformData> customUniforms =
6698 UniformData("uCutoutWithCornerRadius", Property::Type::INTEGER),
6701 TestGraphicsController& graphics = application.GetGraphicsController();
6702 graphics.AddCustomUniforms(customUniforms);
6704 VisualFactory factory = VisualFactory::Get();
6706 // Test (Enable/Disable) CornerRadius, (Enable/Disable) Borderline, (Enable/Disable) Blur, and 3 kind of CutoutPolicy
6707 for(int testCase = 0; testCase < 2 * 2 * 2 * 3; ++testCase)
6709 const bool enableCornerRadius = (testCase & 1);
6710 const bool enableBorderline = (testCase & 2);
6711 const bool enableBlur = (testCase & 4);
6714 const DevelColorVisual::CutoutPolicy::Type cutoutPolicy = (testCase / 8) == 0 ? DevelColorVisual::CutoutPolicy::NONE :
6715 (testCase / 8) == 1 ? DevelColorVisual::CutoutPolicy::CUTOUT_VIEW :
6716 DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS;
6719 Property::Map propertyMap;
6720 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
6721 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
6722 if(enableCornerRadius)
6724 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
6725 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
6727 if(enableBorderline)
6729 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
6730 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
6731 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
6735 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
6737 propertyMap.Insert(DevelColorVisual::Property::CUTOUT_POLICY, cutoutPolicy);
6739 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
6741 DummyControl dummyControl = DummyControl::New(true);
6742 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6743 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
6744 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6745 application.GetScene().Add(dummyControl);
6747 application.SendNotification();
6748 application.Render();
6750 TestShaderCodeContainSubstrings(
6753 {"#define IS_REQUIRED_BLUR", enableBlur},
6754 {"#define IS_REQUIRED_BORDERLINE", !enableBlur && enableBorderline}, ///< Since borderline is ignored, due to blur enabled.
6755 {"#define IS_REQUIRED_ROUNDED_CORNER", enableCornerRadius},
6756 {"#define IS_REQUIRED_CUTOUT", cutoutPolicy != DevelColorVisual::CutoutPolicy::NONE},
6760 if(cutoutPolicy != DevelColorVisual::CutoutPolicy::NONE)
6762 auto& gl = application.GetGlAbstraction();
6763 DALI_TEST_EQUALS(gl.CheckUniformValue<int>("uCutoutWithCornerRadius", cutoutPolicy == DevelColorVisual::CutoutPolicy::CUTOUT_VIEW_WITH_CORNER_RADIUS ? 1 : 0), true, TEST_LOCATION);
6765 dummyControl.Unparent();
6767 application.SendNotification();
6768 application.Render();