2 * Copyright (c) 2022 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());
145 void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, bool>> substringCheckList, const char* location)
147 Renderer renderer = control.GetRendererAt(0);
148 Shader shader = renderer.GetShader();
149 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
150 Property::Map* map = value.GetMap();
151 DALI_TEST_CHECK(map);
153 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
154 DALI_TEST_CHECK(fragment);
155 std::string fragmentShader;
156 DALI_TEST_CHECK(fragment->Get(fragmentShader));
157 for(const auto& checkPair : substringCheckList)
159 const auto& keyword = checkPair.first;
160 const auto& expect = checkPair.second;
161 tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
162 DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
165 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
166 std::string vertexShader;
167 DALI_TEST_CHECK(vertex->Get(vertexShader));
168 for(const auto& checkPair : substringCheckList)
170 const auto& keyword = checkPair.first;
171 const auto& expect = checkPair.second;
172 tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
173 DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
179 void dali_visual_startup(void)
181 test_return_value = TET_UNDEF;
184 void dali_visual_cleanup(void)
186 test_return_value = TET_PASS;
189 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
192 visual.CreatePropertyMap(map);
193 Property::Value* value = map.Find(mixColorIndex);
194 DALI_TEST_CHECK(value);
196 DALI_TEST_CHECK(value->Get(mixColor1));
197 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
199 value = map.Find(Visual::Property::MIX_COLOR);
200 DALI_TEST_CHECK(value);
202 DALI_TEST_CHECK(value->Get(mixColor2));
203 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
205 value = map.Find(Visual::Property::OPACITY);
206 DALI_TEST_CHECK(value);
208 DALI_TEST_CHECK(value->Get(opacity));
209 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
212 int UtcDaliVisualCopyAndAssignment(void)
214 ToolkitTestApplication application;
215 tet_infoline("UtcDaliVisualCopyAndAssignment");
217 VisualFactory factory = VisualFactory::Get();
218 Property::Map propertyMap;
219 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
220 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
221 Visual::Base visual = factory.CreateVisual(propertyMap);
223 Visual::Base visualCopy(visual);
224 DALI_TEST_CHECK(visual == visualCopy);
226 Visual::Base emptyVisual;
227 Visual::Base emptyVisualCopy(emptyVisual);
228 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
230 Visual::Base visualEquals;
231 visualEquals = visual;
232 DALI_TEST_CHECK(visual == visualEquals);
234 Visual::Base emptyVisualEquals;
235 emptyVisualEquals = emptyVisual;
236 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
240 DALI_TEST_CHECK(visual = visualCopy);
245 int UtcDaliVisualSetName01(void)
247 ToolkitTestApplication application;
248 tet_infoline("UtcDaliVisualSetName");
250 VisualFactory factory = VisualFactory::Get();
251 Property::Map propertyMap;
252 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
253 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
254 Visual::Base visual = factory.CreateVisual(propertyMap);
256 const char* visualName = "backgroundVisual";
257 visual.SetName(visualName);
259 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
264 int UtcDaliVisualSetGetDepthIndex(void)
266 ToolkitTestApplication application;
267 tet_infoline("UtcDaliVisualSetDepthIndex");
269 VisualFactory factory = VisualFactory::Get();
270 Property::Map propertyMap;
271 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
272 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
273 Visual::Base visual = factory.CreateVisual(propertyMap);
275 visual.SetDepthIndex(1);
277 DummyControl dummyControl = DummyControl::New(true);
278 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
279 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
281 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
282 application.GetScene().Add(dummyControl);
284 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
285 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
286 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
288 visual.SetDepthIndex(-1);
289 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
290 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
291 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
296 int UtcDaliVisualSize(void)
298 ToolkitTestApplication application;
299 tet_infoline("UtcDaliVisualSize");
301 VisualFactory factory = VisualFactory::Get();
302 Vector2 controlSize(20.f, 30.f);
306 Dali::Property::Map map;
307 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
308 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
310 Visual::Base colorVisual = factory.CreateVisual(map);
311 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
313 colorVisual.GetNaturalSize(naturalSize);
314 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
318 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
319 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
320 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
321 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
322 Visual::Base imageVisual = factory.CreateVisual(map);
323 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
325 imageVisual.GetNaturalSize(naturalSize);
326 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
328 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
331 float borderSize = 5.f;
333 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
334 map[BorderVisual::Property::COLOR] = Color::RED;
335 map[BorderVisual::Property::SIZE] = borderSize;
336 Visual::Base borderVisual = factory.CreateVisual(map);
337 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
338 borderVisual.GetNaturalSize(naturalSize);
339 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
341 // gradient gradientVisual
342 Property::Map propertyMap;
343 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
344 Vector2 start(-1.f, -1.f);
345 Vector2 end(1.f, 1.f);
346 propertyMap.Insert("mixColor", Color::MAGENTA);
347 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
348 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
349 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
350 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
351 Property::Array stopColors;
352 stopColors.PushBack(Color::RED);
353 stopColors.PushBack(Color::GREEN);
354 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
355 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
356 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
357 gradientVisual.GetNaturalSize(naturalSize);
358 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
360 // animated gradient visual
362 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
363 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
364 animatedGradientVisual.GetNaturalSize(naturalSize);
365 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
366 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
370 // Load some fonts to get the same metrics on different platforms.
371 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
372 fontClient.SetDpi(96u, 96u);
374 char* pathNamePtr = get_current_dir_name();
375 const std::string pathName(pathNamePtr);
378 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
380 // Create a TextVisual with a font size of 12 first
382 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
383 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
384 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
385 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
387 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
388 Vector2 smallTextVisualNaturalSize;
389 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
391 // Then create a TextVisual with a font size of 20
392 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
393 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
394 Vector2 largeTextVisualNaturalSize;
395 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
397 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
398 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
399 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
401 // The height returned for a particular width should also be greater for the large text visual
402 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
404 //AnimatedImageVisual
405 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
406 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
407 animatedImageVisual.GetNaturalSize(naturalSize);
408 // TEST_GIF_FILE: anim.gif
409 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
410 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
415 int UtcDaliVisualSetOnOffScene(void)
417 ToolkitTestApplication application;
418 tet_infoline("UtcDaliVisualSetOnOffScene");
420 VisualFactory factory = VisualFactory::Get();
421 Property::Map propertyMap;
422 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
423 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
424 Visual::Base visual = factory.CreateVisual(propertyMap);
426 DummyControl actor = DummyControl::New(true);
427 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
428 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
430 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
432 application.SendNotification();
433 application.Render(0);
434 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
436 application.GetScene().Add(actor);
438 application.SendNotification();
439 application.Render(0);
440 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
442 application.GetScene().Remove(actor);
444 application.SendNotification();
445 application.Render(0);
446 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
451 int UtcDaliVisualSetOnOffScene2(void)
453 ToolkitTestApplication application;
454 tet_infoline("UtcDaliVisualSetOnOffScene2");
456 VisualFactory factory = VisualFactory::Get();
457 Property::Map propertyMap;
458 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
459 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
460 Visual::Base visual = factory.CreateVisual(propertyMap);
462 DummyControl actor = DummyControl::New(true);
463 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
464 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
466 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
468 application.SendNotification();
469 application.Render(0);
470 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
473 application.GetScene().Add(actor);
475 application.SendNotification();
476 application.Render(0);
478 // Wait for loading & rasterization
479 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
481 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
482 Renderer renderer = actor.GetRendererAt(0);
483 auto textures = renderer.GetTextures();
484 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
486 application.GetScene().Remove(actor);
488 application.SendNotification();
489 application.Render(0);
490 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
493 application.GetScene().Add(actor);
495 application.SendNotification();
496 application.Render(0);
497 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
498 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
499 renderer = actor.GetRendererAt(0);
500 textures = renderer.GetTextures();
501 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
503 application.GetScene().Remove(actor);
505 application.SendNotification();
506 application.Render(0);
507 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
512 int UtcDaliVisualGetPropertyMap1(void)
514 ToolkitTestApplication application;
515 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
517 VisualFactory factory = VisualFactory::Get();
518 Property::Map propertyMap;
519 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
520 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
521 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
522 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
523 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
524 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
525 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
526 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
527 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
529 Property::Map resultMap;
530 colorVisual.CreatePropertyMap(resultMap);
532 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
533 DALI_TEST_CHECK(typeValue);
534 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
536 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
537 DALI_TEST_CHECK(colorValue);
538 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
540 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
541 DALI_TEST_CHECK(cornerRadiusValue);
542 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
544 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
545 DALI_TEST_CHECK(cornerRadiusPolicyValue);
546 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
548 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
549 DALI_TEST_CHECK(borderlineWidthValue);
550 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
552 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
553 DALI_TEST_CHECK(borderlineColorValue);
554 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
556 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
557 DALI_TEST_CHECK(borderlineOffsetValue);
558 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
560 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
561 DALI_TEST_CHECK(blurRadiusValue);
562 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
564 // change the blend color
565 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
566 colorVisual = factory.CreateVisual(propertyMap);
567 colorVisual.CreatePropertyMap(resultMap);
569 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
570 DALI_TEST_CHECK(colorValue);
571 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
574 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
576 colorVisual = factory.CreateVisual(propertyMap);
577 colorVisual.CreatePropertyMap(resultMap);
579 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
580 DALI_TEST_CHECK(blurRadiusValue);
581 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
586 int UtcDaliVisualGetPropertyMap2(void)
588 ToolkitTestApplication application;
589 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
591 VisualFactory factory = VisualFactory::Get();
592 Property::Map propertyMap;
593 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
594 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
595 propertyMap.Insert("borderColor", Color::BLUE);
596 propertyMap.Insert("borderSize", 5.f);
597 propertyMap.Insert("antiAliasing", true);
598 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
600 Property::Map resultMap;
601 borderVisual.CreatePropertyMap(resultMap);
603 // check the property values from the returned map from visual
604 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
605 DALI_TEST_CHECK(typeValue);
606 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
608 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
609 DALI_TEST_CHECK(colorValue);
610 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
612 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
613 DALI_TEST_CHECK(sizeValue);
614 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
616 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
617 DALI_TEST_CHECK(AAValue);
618 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
620 Property::Map propertyMap1;
621 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
622 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
623 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
624 borderVisual = factory.CreateVisual(propertyMap1);
625 borderVisual.CreatePropertyMap(resultMap);
627 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
628 DALI_TEST_CHECK(typeValue);
629 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
631 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
632 DALI_TEST_CHECK(colorValue);
633 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
635 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
636 DALI_TEST_CHECK(sizeValue);
637 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
642 int UtcDaliVisualGetPropertyMap2N(void)
644 ToolkitTestApplication application;
645 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
647 VisualFactory factory = VisualFactory::Get();
648 Property::Map propertyMap;
649 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
650 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
652 tet_infoline("Test that the visual is created, with a default renderer");
653 DALI_TEST_CHECK(borderVisual);
655 DummyControl dummyControl = DummyControl::New(true);
656 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
657 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
658 application.GetScene().Add(dummyControl);
660 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
665 int UtcDaliVisualGetPropertyMap3(void)
667 ToolkitTestApplication application;
668 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
670 VisualFactory factory = VisualFactory::Get();
671 DALI_TEST_CHECK(factory);
673 Property::Map propertyMap;
674 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
676 Vector2 start(-1.f, -1.f);
677 Vector2 end(1.f, 1.f);
678 propertyMap.Insert("startPosition", start);
679 propertyMap.Insert("endPosition", end);
680 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
682 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
684 Property::Array stopColors;
685 stopColors.PushBack(Color::RED);
686 stopColors.PushBack(Color::GREEN);
687 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
689 float borderlineWidth = 4.0f;
690 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
691 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
692 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
694 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
696 Property::Map resultMap;
697 gradientVisual.CreatePropertyMap(resultMap);
699 // check the property values from the returned map from visual
700 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
701 DALI_TEST_CHECK(value);
702 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
704 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
705 DALI_TEST_CHECK(value);
706 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
708 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
709 DALI_TEST_CHECK(value);
710 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
712 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
713 DALI_TEST_CHECK(value);
714 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
716 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
717 DALI_TEST_CHECK(value);
718 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
720 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
721 DALI_TEST_CHECK(value);
722 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
724 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
725 DALI_TEST_CHECK(value);
726 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
728 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
729 DALI_TEST_CHECK(value);
730 Property::Array* offsetArray = value->GetArray();
731 DALI_TEST_CHECK(offsetArray->Count() == 2);
732 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
733 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
735 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
736 DALI_TEST_CHECK(value);
737 Property::Array* colorArray = value->GetArray();
738 DALI_TEST_CHECK(colorArray->Count() == 2);
739 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
740 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
745 int UtcDaliVisualGetPropertyMap4(void)
747 ToolkitTestApplication application;
748 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
750 VisualFactory factory = VisualFactory::Get();
751 DALI_TEST_CHECK(factory);
753 Property::Map propertyMap;
754 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
756 Vector2 center(100.f, 100.f);
757 float radius = 100.f;
758 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
759 propertyMap.Insert(GradientVisual::Property::CENTER, center);
760 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
761 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
763 Property::Array stopColors;
764 stopColors.PushBack(Color::RED);
765 stopColors.PushBack(Color::BLACK);
766 stopColors.PushBack(Color::GREEN);
767 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
769 float borderlineWidth = 8.0f;
770 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
771 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
772 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
774 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
775 DALI_TEST_CHECK(gradientVisual);
777 Property::Map resultMap;
778 gradientVisual.CreatePropertyMap(resultMap);
780 // check the property values from the returned map from visual
781 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
782 DALI_TEST_CHECK(value);
783 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
785 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
786 DALI_TEST_CHECK(value);
787 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
789 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
790 DALI_TEST_CHECK(value);
791 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
793 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
794 DALI_TEST_CHECK(value);
795 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
797 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
798 DALI_TEST_CHECK(value);
799 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
801 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
802 DALI_TEST_CHECK(value);
803 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
805 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
806 DALI_TEST_CHECK(value);
807 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
809 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
810 DALI_TEST_CHECK(value);
811 Property::Array* offsetArray = value->GetArray();
812 DALI_TEST_CHECK(offsetArray->Count() == 3);
813 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
814 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
815 // any stop value will be clamped to [0.0, 1.0];
816 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
818 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
819 DALI_TEST_CHECK(value);
820 Property::Array* colorArray = value->GetArray();
821 DALI_TEST_CHECK(colorArray->Count() == 3);
822 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
823 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
824 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
829 int UtcDaliVisualGetPropertyMap5(void)
831 ToolkitTestApplication application;
832 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
834 VisualFactory factory = VisualFactory::Get();
835 Property::Map propertyMap;
836 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
837 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
838 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
839 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
840 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
841 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
842 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
843 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
844 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
845 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
846 propertyMap.Insert("synchronousLoading", true);
848 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
849 DALI_TEST_CHECK(imageVisual);
851 Property::Map resultMap;
852 imageVisual.CreatePropertyMap(resultMap);
854 // check the property values from the returned map from visual
855 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
856 DALI_TEST_CHECK(value);
857 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
859 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
860 DALI_TEST_CHECK(value);
861 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
863 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
864 DALI_TEST_CHECK(value);
865 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
867 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
868 DALI_TEST_CHECK(value);
869 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
871 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
872 DALI_TEST_CHECK(value);
873 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
875 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
876 DALI_TEST_CHECK(value);
877 DALI_TEST_CHECK(value->Get<int>() == 20);
879 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
880 DALI_TEST_CHECK(value);
881 DALI_TEST_CHECK(value->Get<int>() == 30);
883 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
884 DALI_TEST_CHECK(value);
885 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
887 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
888 DALI_TEST_CHECK(value);
889 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
891 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
892 DALI_TEST_CHECK(value);
893 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
895 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
896 DALI_TEST_CHECK(value);
897 DALI_TEST_CHECK(value->Get<bool>() == true);
902 int UtcDaliVisualGetPropertyMap6(void)
904 ToolkitTestApplication application;
905 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
907 Rect<int> border(1, 1, 1, 1);
909 VisualFactory factory = VisualFactory::Get();
910 Property::Map propertyMap;
911 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
912 propertyMap.Insert("mixColor", Color::MAGENTA);
913 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
914 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
915 propertyMap.Insert(ImageVisual::Property::BORDER, border);
916 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
917 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
918 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
920 Property::Map resultMap;
921 nPatchVisual.CreatePropertyMap(resultMap);
923 // check the property values from the returned map from visual
924 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
925 DALI_TEST_CHECK(value);
926 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
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::URL, Property::STRING);
933 DALI_TEST_CHECK(value);
934 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
936 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
937 DALI_TEST_CHECK(value);
938 DALI_TEST_CHECK(value->Get<bool>());
940 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
941 DALI_TEST_CHECK(value);
942 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
944 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
945 DALI_TEST_CHECK(value);
946 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
948 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
949 DALI_TEST_CHECK(value);
950 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
952 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
954 Property::Map propertyMap1;
955 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
956 propertyMap1.Insert("mixColor", Color::MAGENTA);
957 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
958 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
959 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
960 nPatchVisual = factory.CreateVisual(propertyMap1);
962 nPatchVisual.CreatePropertyMap(resultMap);
964 // check the property values from the returned map from visual
965 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
966 DALI_TEST_CHECK(value);
967 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
969 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
970 DALI_TEST_CHECK(value);
971 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
973 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
974 DALI_TEST_CHECK(value);
975 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
977 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
978 DALI_TEST_CHECK(value);
979 DALI_TEST_CHECK(value->Get<bool>());
981 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
982 DALI_TEST_CHECK(value);
983 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
988 int UtcDaliVisualGetPropertyMap7(void)
990 ToolkitTestApplication application;
991 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
993 // request SvgVisual with a property map
994 VisualFactory factory = VisualFactory::Get();
995 Property::Map propertyMap;
996 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
997 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
998 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
999 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
1000 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
1002 Property::Map resultMap;
1003 svgVisual.CreatePropertyMap(resultMap);
1004 // check the property values from the returned map from a visual
1005 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1006 DALI_TEST_CHECK(value);
1007 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1009 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1010 DALI_TEST_CHECK(value);
1011 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1013 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1014 DALI_TEST_CHECK(value);
1015 DALI_TEST_CHECK(value->Get<bool>() == false);
1017 // request SvgVisual with a property map 2
1018 propertyMap.Clear();
1019 propertyMap["visualType"] = Visual::SVG;
1020 propertyMap["mixColor"] = Color::WHITE;
1021 propertyMap["url"] = TEST_SVG_FILE_NAME;
1022 propertyMap["atlasing"] = true;
1023 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1026 svgVisual1.CreatePropertyMap(resultMap);
1027 // check the property values from the returned map from a visual
1028 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1029 DALI_TEST_CHECK(value);
1030 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1032 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1033 DALI_TEST_CHECK(value);
1034 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1036 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1037 DALI_TEST_CHECK(value);
1038 DALI_TEST_CHECK(value->Get<bool>() == true);
1040 // request SvgVisual with an URL
1041 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1043 svgVisual2.CreatePropertyMap(resultMap);
1044 // check the property values from the returned map from a visual
1045 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1046 DALI_TEST_CHECK(value);
1047 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1049 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1050 DALI_TEST_CHECK(value);
1051 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1057 int UtcDaliVisualGetPropertyMap8(void)
1059 ToolkitTestApplication application;
1060 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1062 //Request MeshVisual using a property map.
1063 VisualFactory factory = VisualFactory::Get();
1064 Property::Map propertyMap;
1065 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1066 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1067 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1068 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1069 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1070 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1071 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1072 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1074 Property::Map resultMap;
1075 meshVisual.CreatePropertyMap(resultMap);
1076 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1078 //Check values in the result map are identical to the initial map's values.
1079 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1080 DALI_TEST_CHECK(value);
1081 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1083 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1084 DALI_TEST_CHECK(value);
1085 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1087 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1088 DALI_TEST_CHECK(value);
1089 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1091 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1092 DALI_TEST_CHECK(value);
1093 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1095 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1096 DALI_TEST_CHECK(value);
1097 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1099 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1100 DALI_TEST_CHECK(value);
1101 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1106 //Primitive shape visual
1107 int UtcDaliVisualGetPropertyMap9(void)
1109 ToolkitTestApplication application;
1110 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1112 static std::vector<UniformData> customUniforms =
1114 UniformData("mixColor", Property::Type::VECTOR3),
1117 TestGraphicsController& graphics = application.GetGraphicsController();
1118 graphics.AddCustomUniforms(customUniforms);
1120 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1121 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1123 //Request PrimitiveVisual using a property map.
1124 VisualFactory factory = VisualFactory::Get();
1125 Property::Map propertyMap;
1126 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1127 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1128 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1129 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1130 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1131 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1132 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1133 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1134 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1135 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1136 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1137 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1138 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1139 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1141 Property::Map resultMap;
1142 primitiveVisual.CreatePropertyMap(resultMap);
1144 //Check values in the result map are identical to the initial map's values.
1145 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1146 DALI_TEST_CHECK(value);
1147 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1149 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1150 DALI_TEST_CHECK(value);
1151 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1153 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1154 DALI_TEST_CHECK(value);
1155 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1156 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1158 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1159 DALI_TEST_CHECK(value);
1160 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1162 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1163 DALI_TEST_CHECK(value);
1164 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1166 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1167 DALI_TEST_CHECK(value);
1168 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1170 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1171 DALI_TEST_CHECK(value);
1172 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1174 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1175 DALI_TEST_CHECK(value);
1176 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1178 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1179 DALI_TEST_CHECK(value);
1180 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1182 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1183 DALI_TEST_CHECK(value);
1184 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1186 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1187 DALI_TEST_CHECK(value);
1188 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1190 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1191 DALI_TEST_CHECK(value);
1192 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1194 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1195 DALI_TEST_CHECK(value);
1196 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1198 DummyControl actor = DummyControl::New(true);
1199 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1200 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1201 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1202 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1203 application.GetScene().Add(actor);
1205 Animation animation = Animation::New(1.0f);
1206 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1208 application.SendNotification();
1209 application.Render(0);
1210 application.Render(1000);
1211 application.SendNotification();
1213 auto& gl = application.GetGlAbstraction();
1214 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1216 tet_infoline("Check property map after animation");
1218 primitiveVisual.CreatePropertyMap(resultMap);
1219 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1220 DALI_TEST_CHECK(value);
1221 color = value->Get<Vector4>();
1222 // Ignore alpha part
1223 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1229 int UtcDaliVisualGetPropertyMap10(void)
1231 ToolkitTestApplication application;
1232 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1234 //Request PrimitiveVisual using a property map.
1235 VisualFactory factory = VisualFactory::Get();
1237 Property::Map propertyMap;
1238 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1239 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1240 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1241 propertyMap.Insert("enableMarkup", false);
1242 propertyMap.Insert("text", "Hello world");
1243 propertyMap.Insert("fontFamily", "TizenSans");
1245 Property::Map fontStyleMapSet;
1246 fontStyleMapSet.Insert("weight", "bold");
1247 propertyMap.Insert("fontStyle", fontStyleMapSet);
1249 propertyMap.Insert("pointSize", 12.f);
1250 propertyMap.Insert("multiLine", true);
1251 propertyMap.Insert("horizontalAlignment", "CENTER");
1252 propertyMap.Insert("verticalAlignment", "CENTER");
1253 propertyMap.Insert("textColor", Color::RED);
1255 Property::Map shadowMapSet;
1256 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1258 Property::Map underlineMapSet;
1259 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));
1261 Property::Map outlineMapSet;
1262 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1264 Property::Map backgroundMapSet;
1265 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1267 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1269 Property::Map resultMap;
1270 textVisual.CreatePropertyMap(resultMap);
1272 //Check values in the result map are identical to the initial map's values.
1273 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1274 DALI_TEST_CHECK(value);
1275 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1277 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1278 DALI_TEST_CHECK(value);
1279 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1281 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1282 DALI_TEST_CHECK(value);
1283 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1285 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1286 DALI_TEST_CHECK(value);
1287 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1289 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1290 DALI_TEST_CHECK(value);
1292 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1293 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1294 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1296 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1297 DALI_TEST_CHECK(value);
1298 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1300 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1301 DALI_TEST_CHECK(value);
1302 DALI_TEST_CHECK(value->Get<bool>());
1304 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1305 DALI_TEST_CHECK(value);
1306 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1308 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1309 DALI_TEST_CHECK(value);
1310 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1312 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1313 DALI_TEST_CHECK(value);
1314 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1316 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1317 DALI_TEST_CHECK(value);
1318 DALI_TEST_CHECK(!value->Get<bool>());
1320 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1321 DALI_TEST_CHECK(value);
1323 Property::Map shadowMapGet = value->Get<Property::Map>();
1324 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1325 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1327 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1328 DALI_TEST_CHECK(value);
1330 Property::Map underlineMapGet = value->Get<Property::Map>();
1331 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1332 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1334 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1335 DALI_TEST_CHECK(value);
1337 Property::Map outlineMapGet = value->Get<Property::Map>();
1338 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1339 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1341 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1342 DALI_TEST_CHECK(value);
1344 Property::Map backgroundMapGet = value->Get<Property::Map>();
1345 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1346 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1351 int UtcDaliVisualGetPropertyMap11(void)
1353 ToolkitTestApplication application;
1354 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1356 VisualFactory factory = VisualFactory::Get();
1357 DALI_TEST_CHECK(factory);
1359 Property::Map propertyMap;
1360 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1362 Vector2 start(-0.5f, 0.5f);
1363 Vector2 end(0.5f, -0.0f);
1364 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1365 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1366 Vector2 rotate_center(0.0f, 0.4f);
1367 float rotate_amount = 1.57f;
1368 float offset = 100.f;
1370 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1371 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1372 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1374 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1375 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1376 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1377 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1378 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1379 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1380 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1382 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1383 DALI_TEST_CHECK(animatedGradientVisual);
1385 Property::Map resultMap;
1386 animatedGradientVisual.CreatePropertyMap(resultMap);
1388 // check the property values from the returned map from visual
1389 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1390 DALI_TEST_CHECK(value);
1391 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1393 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1394 DALI_TEST_CHECK(value);
1395 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1397 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1398 DALI_TEST_CHECK(value);
1399 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1401 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1402 DALI_TEST_CHECK(value);
1403 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1405 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1406 DALI_TEST_CHECK(value);
1407 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1409 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1410 DALI_TEST_CHECK(value);
1411 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1413 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1414 DALI_TEST_CHECK(value);
1415 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1417 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1418 DALI_TEST_CHECK(value);
1419 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1421 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1422 DALI_TEST_CHECK(value);
1423 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1425 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1426 DALI_TEST_CHECK(value);
1427 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1429 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1430 DALI_TEST_CHECK(value);
1431 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1436 int UtcDaliVisualGetPropertyMap12(void)
1438 ToolkitTestApplication application;
1439 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1441 // Case 1 : Set values by index
1443 tet_printf(" - Set Values by Index\n");
1444 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1445 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1446 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1448 tet_printf("test with delay [%f]\n", _delay);
1449 VisualFactory factory = VisualFactory::Get();
1450 DALI_TEST_CHECK(factory);
1452 Property::Map propertyMap;
1453 Property::Map animationMap;
1454 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1456 float duration = 1.1f;
1457 float delay = _delay;
1458 float repeat_delay = 0.4f;
1460 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1462 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1463 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1465 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1466 animationMap.Clear();
1467 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1468 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1469 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1470 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1471 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1472 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1473 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1474 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1475 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1477 return animationMap;
1480 Vector2 start1(-0.5f, 0.5f);
1481 Vector2 end1(0.5f, -0.5f);
1482 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1483 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1484 Vector2 rotate_center1(0.0f, 0.4f);
1485 float rotate_amount1 = 0.0f;
1486 float offset1 = 0.f;
1488 Vector2 start2(-0.5f, -0.5f);
1489 Vector2 end2(0.5f, 0.5f);
1490 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1491 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1492 Vector2 rotate_center2(0.0f, -0.4f);
1493 float rotate_amount2 = 6.2832f;
1494 float offset2 = 2.f;
1496 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1497 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1498 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1500 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1501 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1502 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1503 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1504 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1505 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1506 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1508 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1509 DALI_TEST_CHECK(animatedGradientVisual);
1511 Property::Map resultMap;
1512 animatedGradientVisual.CreatePropertyMap(resultMap);
1514 // check the property values from the returned map from visual
1515 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1516 DALI_TEST_CHECK(value);
1517 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1519 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1520 DALI_TEST_CHECK(value);
1521 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1523 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1524 DALI_TEST_CHECK(value);
1525 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1527 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1528 DALI_TEST_CHECK(value);
1529 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1531 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 {
1532 tet_printf("Check value at %d\n", line_num);
1533 value = resultMap.Find(index, Property::MAP);
1534 DALI_TEST_CHECK(value);
1535 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1536 Property::Map* temp_map = value->GetMap();
1537 DALI_TEST_CHECK(temp_map);
1539 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1540 Property::Value* res = temp_map->Find(index);
1541 DALI_TEST_CHECK(res);
1545 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1546 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1547 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1548 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1549 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1550 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1551 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1552 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1553 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1556 // check the animation map data is good
1557 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1558 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1559 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1560 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1561 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1562 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1563 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1567 // Case 2 : Set values by string
1569 tet_printf(" - Set Values by String\n");
1570 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1571 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1572 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1574 tet_printf("test with delay [%f]\n", _delay);
1575 VisualFactory factory = VisualFactory::Get();
1576 DALI_TEST_CHECK(factory);
1578 Property::Map propertyMap;
1579 Property::Map animationMap;
1580 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1582 float duration = 1.1f;
1583 float delay = _delay;
1584 float repeat_delay = 0.4f;
1586 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1588 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1589 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1591 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1592 animationMap.Clear();
1593 animationMap.Insert("startValue", start);
1594 animationMap.Insert("targetValue", target);
1595 animationMap.Insert("directionType", "BACKWARD");
1596 animationMap.Insert("duration", duration);
1597 animationMap.Insert("delay", delay);
1598 animationMap.Insert("repeat", loop_count);
1599 animationMap.Insert("repeatDelay", repeat_delay);
1600 animationMap.Insert("motionType", "MIRROR");
1601 animationMap.Insert("easingType", "IN_OUT");
1603 return animationMap;
1606 Vector2 start1(-0.5f, 0.5f);
1607 Vector2 end1(0.5f, -0.5f);
1608 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1609 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1610 Vector2 rotate_center1(0.0f, 0.4f);
1611 float rotate_amount1 = 0.0f;
1612 float offset1 = 0.f;
1614 Vector2 start2(-0.5f, -0.5f);
1615 Vector2 end2(0.5f, 0.5f);
1616 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1617 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1618 Vector2 rotate_center2(0.0f, -0.4f);
1619 float rotate_amount2 = 6.2832f;
1620 float offset2 = 2.f;
1622 // For test mix the type string/index key and string/index value works well.
1623 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1624 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1625 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1627 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1628 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1629 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1630 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1631 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1632 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1633 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1635 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1636 DALI_TEST_CHECK(animatedGradientVisual);
1638 Property::Map resultMap;
1639 animatedGradientVisual.CreatePropertyMap(resultMap);
1641 // check the property values from the returned map from visual
1642 // Note : resultMap from CreatePropertyMap only contain indexKey
1643 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1644 DALI_TEST_CHECK(value);
1645 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1647 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1648 DALI_TEST_CHECK(value);
1649 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1651 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1652 DALI_TEST_CHECK(value);
1653 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1655 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1656 DALI_TEST_CHECK(value);
1657 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1659 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 {
1660 tet_printf("Check value at %d\n", line_num);
1661 value = resultMap.Find(index, Property::MAP);
1662 DALI_TEST_CHECK(value);
1663 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1664 Property::Map* temp_map = value->GetMap();
1665 DALI_TEST_CHECK(temp_map);
1667 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1668 Property::Value* res = temp_map->Find(index);
1669 DALI_TEST_CHECK(res);
1673 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1674 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1675 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1676 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1677 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1678 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1679 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1680 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1681 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1684 // check the animation map data is good
1685 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1686 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1687 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1688 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1689 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1690 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1691 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1697 int UtcDaliVisualGetPropertyMap13(void)
1699 ToolkitTestApplication application;
1700 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1702 for(int _direction = 0; _direction <= 1; ++_direction)
1704 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1706 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1707 VisualFactory factory = VisualFactory::Get();
1708 DALI_TEST_CHECK(factory);
1710 Property::Map propertyMap;
1711 Property::Map animationMap;
1712 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1714 float duration = 1.0f;
1715 float delay = _delay;
1716 float repeat_delay = 0.5f;
1718 int direction = _direction;
1719 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1720 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1721 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1723 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1724 animationMap.Clear();
1725 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1726 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1728 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1730 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1731 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1732 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1733 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1734 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1735 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1736 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1737 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1739 return animationMap;
1742 Vector2 start1(-0.5f, 0.5f);
1743 Vector2 end1(0.5f, -0.5f);
1744 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1745 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1746 Vector2 rotate_center1(1.0f, 0.4f);
1747 float rotate_amount1 = 2.0f;
1748 float offset1 = 1.f;
1750 Vector2 start2(-0.5f, -0.5f);
1751 Vector2 end2(0.5f, 0.5f);
1752 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1753 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1754 Vector2 rotate_center2(1.0f, -0.4f);
1755 float rotate_amount2 = 1.0f;
1756 float offset2 = 3.f;
1758 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1759 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1760 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1762 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1763 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1764 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1765 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1766 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1767 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1768 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1770 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1771 DALI_TEST_CHECK(animatedGradientVisual);
1773 Property::Map resultMap;
1774 animatedGradientVisual.CreatePropertyMap(resultMap);
1776 // check the property values from the returned map from visual
1777 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1778 DALI_TEST_CHECK(value);
1779 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1781 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1782 DALI_TEST_CHECK(value);
1783 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1785 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1786 DALI_TEST_CHECK(value);
1787 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1789 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1790 DALI_TEST_CHECK(value);
1791 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1793 // If loop_count = 0, Animation doesn't created.
1794 // Optimized resultMap only have one value, which is target value
1795 // Note: target value will be changed by direction option.
1796 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1797 DALI_TEST_CHECK(value);
1798 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1800 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1801 DALI_TEST_CHECK(value);
1802 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1804 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1805 DALI_TEST_CHECK(value);
1806 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1808 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1809 DALI_TEST_CHECK(value);
1810 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1812 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1813 DALI_TEST_CHECK(value);
1814 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1816 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1817 DALI_TEST_CHECK(value);
1818 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1820 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1821 DALI_TEST_CHECK(value);
1822 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1829 int UtcDaliVisualAnimateArcVisual(void)
1831 ToolkitTestApplication application;
1832 tet_infoline("UtcDaliVisualAnimateArcVisual color");
1834 static std::vector<UniformData> customUniforms =
1836 UniformData("startAngle", Property::Type::FLOAT),
1837 UniformData("sweepAngle", Property::Type::FLOAT),
1840 TestGraphicsController& graphics = application.GetGraphicsController();
1841 graphics.AddCustomUniforms(customUniforms);
1843 VisualFactory factory = VisualFactory::Get();
1844 Property::Map propertyMap;
1845 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ARC);
1846 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1847 propertyMap.Insert(DevelArcVisual::Property::START_ANGLE, 0.0f);
1848 propertyMap.Insert(DevelArcVisual::Property::SWEEP_ANGLE, 90.0f);
1849 propertyMap.Insert(DevelArcVisual::Property::CAP, DevelArcVisual::Cap::ROUND);
1850 propertyMap.Insert(DevelArcVisual::Property::THICKNESS, 20.0f);
1851 Visual::Base arcVisual = factory.CreateVisual(propertyMap);
1853 DummyControl actor = DummyControl::New(true);
1854 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1855 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, arcVisual);
1856 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1857 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1858 application.GetScene().Add(actor);
1860 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1862 Renderer renderer = actor.GetRendererAt(0);
1863 Property::Index index = renderer.GetPropertyIndex(DevelArcVisual::Property::SWEEP_ANGLE);
1865 Animation animation = Animation::New(4.0f);
1866 animation.AnimateTo(Property(renderer, index), 50.0f);
1867 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelArcVisual::Property::START_ANGLE), 40.0f);
1870 application.SendNotification();
1871 application.Render(0);
1872 application.Render(2000u); // halfway point
1874 float sweepAngle = renderer.GetCurrentProperty<float>(index);
1875 DALI_TEST_EQUALS(sweepAngle, 70.0f, 0.0001f, TEST_LOCATION);
1876 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 20.0f), true, TEST_LOCATION);
1877 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 70.0f), true, TEST_LOCATION);
1879 application.Render(2000u); // another halfway point
1881 sweepAngle = renderer.GetCurrentProperty<float>(index);
1882 DALI_TEST_EQUALS(sweepAngle, 50.0f, 0.0001f, TEST_LOCATION);
1883 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("startAngle", 40.0f), true, TEST_LOCATION);
1884 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("sweepAngle", 50.0f), true, TEST_LOCATION);
1889 int UtcDaliVisualAnimateBorderVisual01(void)
1891 ToolkitTestApplication application;
1892 tet_infoline("UtcDaliAnimateBorderVisual Color");
1894 static std::vector<UniformData> customUniforms =
1896 UniformData("borderColor", Property::Type::VECTOR4),
1897 UniformData("mixColor", Property::Type::VECTOR3),
1900 TestGraphicsController& graphics = application.GetGraphicsController();
1901 graphics.AddCustomUniforms(customUniforms);
1903 VisualFactory factory = VisualFactory::Get();
1904 Property::Map propertyMap;
1905 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1906 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1907 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1908 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1909 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1912 map["target"] = "testVisual";
1913 map["property"] = "mixColor";
1914 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1915 map["animator"] = Property::Map()
1916 .Add("alphaFunction", "LINEAR")
1917 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1919 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1921 DummyControl actor = DummyControl::New(true);
1922 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1923 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1924 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1925 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1926 application.GetScene().Add(actor);
1928 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1930 Renderer renderer = actor.GetRendererAt(0);
1931 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1932 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1934 Animation animation = dummyImpl.CreateTransition(transition);
1936 // Animate the mix color through the transition, and the border color through
1937 // programmatic method.
1938 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1941 application.SendNotification();
1942 application.Render(0);
1943 application.Render(2000u); // halfway point between blue and white
1945 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1946 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1947 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1948 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1950 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1951 testColor = Vector4(1, 1, 1, 0.45f);
1952 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1953 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1956 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1957 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1959 application.Render(2000u);
1961 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1962 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1963 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1965 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1966 testColor = Vector4(1, 1, 1, 0.1);
1967 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1968 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1970 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1971 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1976 int UtcDaliVisualAnimateBorderVisual02(void)
1978 ToolkitTestApplication application;
1979 tet_infoline("UtcDaliAnimateBorderVisual Size");
1981 static std::vector<UniformData> customUniforms =
1983 UniformData("borderSize", Property::Type::FLOAT),
1986 TestGraphicsController& graphics = application.GetGraphicsController();
1987 graphics.AddCustomUniforms(customUniforms);
1989 VisualFactory factory = VisualFactory::Get();
1990 Property::Map propertyMap;
1991 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1992 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1993 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1994 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1996 DummyControl actor = DummyControl::New(true);
1997 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1998 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1999 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2000 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2001 application.GetScene().Add(actor);
2003 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2005 Renderer renderer = actor.GetRendererAt(0);
2006 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
2008 Animation animation = Animation::New(4.0f);
2009 animation.AnimateTo(Property(renderer, index), 9.0f);
2012 application.SendNotification();
2013 application.Render(0);
2014 application.Render(2000u); // halfway point
2016 float size = renderer.GetCurrentProperty<float>(index);
2017 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
2018 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
2020 application.Render(2000u); // halfway point between blue and white
2022 size = renderer.GetCurrentProperty<float>(index);
2023 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
2024 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
2029 int UtcDaliVisualAnimateColorVisual(void)
2031 ToolkitTestApplication application;
2032 tet_infoline("UtcDaliAnimateColorVisual mixColor");
2034 static std::vector<UniformData> customUniforms =
2036 UniformData("mixColor", Property::Type::VECTOR3),
2039 TestGraphicsController& graphics = application.GetGraphicsController();
2040 graphics.AddCustomUniforms(customUniforms);
2042 VisualFactory factory = VisualFactory::Get();
2043 Property::Map propertyMap;
2044 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2045 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2046 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
2048 DummyControl actor = DummyControl::New(true);
2049 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2050 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
2051 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2052 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2053 application.GetScene().Add(actor);
2055 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2057 Renderer renderer = actor.GetRendererAt(0);
2058 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
2060 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
2061 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2063 Animation animation = Animation::New(4.0f);
2064 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2067 application.SendNotification();
2068 application.Render(0);
2069 application.Render(2000u); // halfway point
2071 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2072 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2073 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2075 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2077 application.Render(2000u); // halfway point between blue and white
2079 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2080 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2082 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2084 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2085 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2090 int UtcDaliVisualAnimatePrimitiveVisual(void)
2092 ToolkitTestApplication application;
2093 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2095 static std::vector<UniformData> customUniforms =
2097 UniformData("mixColor", Property::Type::VECTOR3),
2100 TestGraphicsController& graphics = application.GetGraphicsController();
2101 graphics.AddCustomUniforms(customUniforms);
2104 VisualFactory factory = VisualFactory::Get();
2105 Property::Map propertyMap;
2106 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2107 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2108 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2109 Visual::Base visual = factory.CreateVisual(propertyMap);
2111 DummyControl actor = DummyControl::New(true);
2112 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2113 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2114 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2115 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2116 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2117 application.GetScene().Add(actor);
2119 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2121 Renderer renderer = actor.GetRendererAt(0);
2123 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2124 const Vector4 TARGET_MIX_COLOR(Color::RED);
2127 map["target"] = "testVisual";
2128 map["property"] = "mixColor";
2129 map["initialValue"] = INITIAL_MIX_COLOR;
2130 map["targetValue"] = TARGET_MIX_COLOR;
2131 map["animator"] = Property::Map()
2132 .Add("alphaFunction", "LINEAR")
2133 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2135 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2137 Animation animation = dummyImpl.CreateTransition(transition);
2138 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2141 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2142 glAbstraction.EnableEnableDisableCallTrace(true);
2143 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2144 std::ostringstream blendStr;
2145 blendStr << std::hex << GL_BLEND;
2147 application.SendNotification();
2148 application.Render(0);
2149 application.Render(2000u); // halfway point
2150 application.SendNotification();
2152 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2153 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2154 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2156 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2158 glEnableStack.Reset();
2160 application.Render(2001u); // go past end
2161 application.SendNotification(); // Trigger signals
2163 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2164 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2165 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2167 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2175 int UtcDaliVisualAnimatedGradientVisual01(void)
2177 ToolkitTestApplication application;
2178 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2180 static std::vector<UniformData> customUniforms =
2182 UniformData("start_point", Property::Type::VECTOR2),
2183 UniformData("end_point", Property::Type::VECTOR2),
2184 UniformData("start_color", Property::Type::VECTOR4),
2185 UniformData("end_color", Property::Type::VECTOR4),
2186 UniformData("rotate_center", Property::Type::VECTOR2),
2187 UniformData("rotate_angle", Property::Type::FLOAT),
2188 UniformData("gradient_offset", Property::Type::FLOAT),
2191 TestGraphicsController& graphics = application.GetGraphicsController();
2192 graphics.AddCustomUniforms(customUniforms);
2195 VisualFactory factory = VisualFactory::Get();
2196 Property::Map propertyMap;
2197 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2198 Visual::Base visual = factory.CreateVisual(propertyMap);
2200 DummyControl actor = DummyControl::New(true);
2201 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2202 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2203 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2204 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2205 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2206 application.GetScene().Add(actor);
2208 application.SendNotification();
2209 application.Render(0);
2210 application.SendNotification();
2212 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2214 for(int step_iter = 0; step_iter < 3; step_iter++)
2216 application.SendNotification();
2217 application.Render(0);
2218 application.Render(750u); // step i/4
2219 application.SendNotification();
2221 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2222 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2223 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2224 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2225 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2226 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2227 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2230 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2231 application.Render(750u); // go to end
2232 application.SendNotification();
2234 application.Render(10u); // finish
2235 application.SendNotification();
2238 application.SendNotification();
2239 application.Render(0u);
2240 application.SendNotification();
2246 int UtcDaliVisualAnimatedGradientVisual02(void)
2248 ToolkitTestApplication application;
2249 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2251 static std::vector<UniformData> customUniforms =
2253 UniformData("start_point", Property::Type::VECTOR2),
2254 UniformData("end_point", Property::Type::VECTOR2),
2255 UniformData("start_color", Property::Type::VECTOR4),
2256 UniformData("end_color", Property::Type::VECTOR4),
2257 UniformData("rotate_center", Property::Type::VECTOR2),
2258 UniformData("rotate_angle", Property::Type::FLOAT),
2259 UniformData("gradient_offset", Property::Type::FLOAT),
2262 TestGraphicsController& graphics = application.GetGraphicsController();
2263 graphics.AddCustomUniforms(customUniforms);
2266 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
2267 int _direction[2] = {0, 1};
2268 int _loop_count[3] = {-1, 0, 1};
2269 int _motion[2] = {0, 1};
2270 int _easing[4] = {0, 1, 2, 3};
2272 int test_case_max = 4 * 2 * 3 * 2 * 4;
2274 int test_case_d = 7; // 7 is the number of animated properties.
2276 float _duration = 0.4f;
2277 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2278 float noise_maker = 0.0f;
2279 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2280 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2282 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2284 VisualFactory factory = VisualFactory::Get();
2285 Property::Map propertyMap;
2286 Property::Map animationMap;
2287 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2289 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2290 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2291 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2293 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& {
2294 int tc = (test_case + tc_offset);
2295 int idx_easing = tc % 4;
2297 int idx_motion = tc % 2;
2299 int idx_loop_count = tc % 3;
2301 int idx_direction = tc % 2;
2303 int idx_delay = tc % 4;
2306 float duration = _duration - _repeat_delay;
2307 float repeat_delay = _repeat_delay;
2308 float delay = _delay[idx_delay] * _duration;
2309 int direction = _direction[idx_direction];
2310 int loop_count = _loop_count[idx_loop_count];
2311 int motion = _motion[idx_motion];
2312 int easing = _easing[idx_easing];
2314 animationMap.Clear();
2315 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2316 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2319 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2323 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2325 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2326 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2327 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2328 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2331 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2335 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2339 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2341 else if(easing == 1)
2343 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2345 else if(easing == 2)
2347 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2351 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2354 return animationMap;
2357 // Give different values for debuging
2358 noise_maker += 1.0f;
2359 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2360 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2361 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2362 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2363 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2364 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2365 float offset1 = 0.f + noise_maker * 0.1f;
2367 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2368 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2369 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2370 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2371 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2372 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2373 float offset2 = 2.f + noise_maker * 0.1f;
2375 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2376 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2377 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2379 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2380 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2381 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2382 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2383 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2384 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2385 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2387 Visual::Base visual = factory.CreateVisual(propertyMap);
2389 DummyControl actor = DummyControl::New(true);
2390 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2391 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2392 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2393 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2394 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2395 application.GetScene().Add(actor);
2397 application.SendNotification();
2398 application.Render(0);
2399 application.SendNotification();
2401 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2403 application.SendNotification();
2405 //Compare between CPU calculated value and Shader Visual calculated value
2406 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 {
2407 int tc = (test_case + tc_offset);
2408 int idx_easing = tc % 4;
2410 int idx_motion = tc % 2;
2412 int idx_loop_count = tc % 3;
2414 int idx_direction = tc % 2;
2416 int idx_delay = tc % 4;
2419 float duration = _duration - _repeat_delay;
2420 float repeat_delay = _repeat_delay;
2421 float delay = _delay[idx_delay] * _duration;
2422 int direction = _direction[idx_direction];
2423 int loop_count = _loop_count[idx_loop_count];
2424 int motion = _motion[idx_motion];
2425 int easing = _easing[idx_easing];
2427 progress -= delay / _duration;
2429 Property::Value s = start;
2430 Property::Value t = target;
2436 float x; ///< Animator progress value
2441 else if(loop_count > 0 && progress + 0.01f > loop_count)
2443 x = (motion == 0) ? 1.0f : 0.0f;
2451 progress = fmodf(progress, 1.0f);
2452 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2457 x = progress * 2.0f;
2464 if(easing == 1) // EASE_IN
2468 else if(easing == 2) // EASE_OUT
2470 x = 2.0f * x - x * x;
2472 else if(easing == 3) // EASE_IN_OUT
2474 x = x * x * (3.0f - 2.0f * x);
2477 if(value_type == 0) // result type is Float
2481 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2482 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2483 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2485 else if(value_type == 1) // result type is Vector2
2489 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2490 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2491 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2493 else if(value_type == 2) // result type is Vector3
2497 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2498 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2499 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2501 else // result type is Vector4
2505 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2506 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2507 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2512 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2514 for(int step_iter = 0; step_iter < 3; step_iter++)
2516 application.SendNotification();
2517 application.Render(_duration * 250.f); // step i/4
2518 application.SendNotification();
2521 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2522 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2523 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2524 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2525 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2526 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2527 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2529 application.SendNotification();
2530 application.Render(_duration * 250.f); // step 4/4 will not test
2531 application.SendNotification();
2535 application.SendNotification();
2537 application.SendNotification();
2538 application.Render(10.f); // tempral time
2539 application.SendNotification();
2546 int UtcDaliVisualAnimatedGradientVisual03(void)
2548 ToolkitTestApplication application;
2549 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2551 static std::vector<UniformData> customUniforms =
2553 UniformData("start_point", Property::Type::VECTOR2),
2554 UniformData("end_point", Property::Type::VECTOR2),
2555 UniformData("start_color", Property::Type::VECTOR4),
2556 UniformData("end_color", Property::Type::VECTOR4),
2557 UniformData("rotate_center", Property::Type::VECTOR2),
2558 UniformData("rotate_angle", Property::Type::FLOAT),
2559 UniformData("gradient_offset", Property::Type::FLOAT),
2562 TestGraphicsController& graphics = application.GetGraphicsController();
2563 graphics.AddCustomUniforms(customUniforms);
2566 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
2567 int _direction[2] = {0, 1};
2568 int _loop_count[3] = {-1, 0, 1};
2569 int _motion[2] = {0, 1};
2570 int _easing[4] = {0, 1, 2, 3};
2572 int test_case_max = 4 * 2 * 3 * 2 * 4;
2574 int test_case_d = 7; // 7 is the number of animated properties.
2576 float _duration = 0.4f;
2577 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2578 float noise_maker = 0.2f;
2579 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2580 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2582 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2584 VisualFactory factory = VisualFactory::Get();
2585 Property::Map propertyMap;
2586 Property::Map animationMap;
2587 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2589 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& {
2590 int tc = (test_case + tc_offset);
2591 int idx_easing = tc % 4;
2593 int idx_motion = tc % 2;
2595 int idx_loop_count = tc % 3;
2597 int idx_direction = tc % 2;
2599 int idx_delay = tc % 4;
2602 float duration = _duration - _repeat_delay;
2603 float repeat_delay = _repeat_delay;
2604 float delay = _delay[idx_delay] * _duration;
2605 int direction = _direction[idx_direction];
2606 int loop_count = _loop_count[idx_loop_count];
2607 int motion = _motion[idx_motion];
2608 int easing = _easing[idx_easing];
2610 animationMap.Clear();
2611 animationMap.Insert("startValue", start);
2612 animationMap.Insert("targetValue", target);
2615 animationMap.Insert("directionType", "FORWARD");
2619 animationMap.Insert("directionType", "BACKWARD");
2621 animationMap.Insert("duration", duration);
2622 animationMap.Insert("delay", delay);
2623 animationMap.Insert("repeat", loop_count);
2624 animationMap.Insert("repeatDelay", repeat_delay);
2627 animationMap.Insert("motionType", "LOOP");
2631 animationMap.Insert("motionType", "MIRROR");
2635 animationMap.Insert("easingType", "LINEAR");
2637 else if(easing == 1)
2639 animationMap.Insert("easingType", "IN");
2641 else if(easing == 2)
2643 animationMap.Insert("easingType", "OUT");
2647 animationMap.Insert("easingType", "IN_OUT");
2650 return animationMap;
2653 // Give different values for debuging
2654 noise_maker += 0.8f;
2655 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2656 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2657 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2658 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2659 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2660 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2661 float offset1 = 0.f + noise_maker * 0.1f;
2663 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2664 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2665 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2666 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2667 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2668 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2669 float offset2 = 2.f + noise_maker * 0.1f;
2671 propertyMap.Insert("gradientType", "LINEAR");
2672 propertyMap.Insert("unitType", "USER_SPACE");
2673 propertyMap.Insert("spreadType", "CLAMP");
2675 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2676 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2677 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2678 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2679 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2680 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2681 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2683 Visual::Base visual = factory.CreateVisual(propertyMap);
2685 DummyControl actor = DummyControl::New(true);
2686 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2687 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2688 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2689 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2690 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2691 application.GetScene().Add(actor);
2693 application.SendNotification();
2694 application.Render(0);
2695 application.SendNotification();
2697 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2699 application.SendNotification();
2701 //Compare between CPU calculated value and Shader Visual calculated value
2702 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 {
2703 int tc = (test_case + tc_offset);
2704 int idx_easing = tc % 4;
2706 int idx_motion = tc % 2;
2708 int idx_loop_count = tc % 3;
2710 int idx_direction = tc % 2;
2712 int idx_delay = tc % 4;
2715 float duration = _duration - _repeat_delay;
2716 float repeat_delay = _repeat_delay;
2717 float delay = _delay[idx_delay] * _duration;
2718 int direction = _direction[idx_direction];
2719 int loop_count = _loop_count[idx_loop_count];
2720 int motion = _motion[idx_motion];
2721 int easing = _easing[idx_easing];
2723 progress -= delay / _duration;
2725 Property::Value s = start;
2726 Property::Value t = target;
2732 float x; ///< Animator progress value
2737 else if(loop_count > 0 && progress + 0.01f > loop_count)
2739 x = (motion == 0) ? 1.0f : 0.0f;
2747 progress = fmodf(progress, 1.0f);
2748 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2753 x = progress * 2.0f;
2760 if(easing == 1) // EASE_IN
2764 else if(easing == 2) // EASE_OUT
2766 x = 2.0f * x - x * x;
2768 else if(easing == 3) // EASE_IN_OUT
2770 x = x * x * (3.0f - 2.0f * x);
2773 if(value_type == 0) // result type is Float
2777 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2778 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2779 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2781 else if(value_type == 1) // result type is Vector2
2785 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2786 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2787 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2789 else if(value_type == 2) // result type is Vector3
2793 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2794 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2795 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2797 else // result type is Vector4
2801 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2802 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2803 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2808 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2810 for(int step_iter = 0; step_iter < 3; step_iter++)
2812 application.SendNotification();
2813 application.Render(_duration * 250.f); // step i/4
2814 application.SendNotification();
2817 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2818 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2819 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2820 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2821 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2822 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2823 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2825 application.SendNotification();
2826 application.Render(_duration * 250.f); // step 4/4 will not test
2827 application.SendNotification();
2831 application.SendNotification();
2833 application.SendNotification();
2834 application.Render(10.f); // tempral time
2835 application.SendNotification();
2842 int UtcDaliVisualWireframeVisual(void)
2844 ToolkitTestApplication application;
2846 VisualFactory factory = VisualFactory::Get();
2847 Property::Map propertyMap;
2848 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2850 // Create the visual.
2851 Visual::Base visual = factory.CreateVisual(propertyMap);
2853 DALI_TEST_CHECK(visual);
2855 Property::Map resultMap;
2856 visual.CreatePropertyMap(resultMap);
2858 // Check the property values from the returned map from visual
2859 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2860 DALI_TEST_CHECK(value);
2861 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2866 int UtcDaliVisualGetTransform(void)
2868 ToolkitTestApplication application;
2869 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2871 VisualFactory factory = VisualFactory::Get();
2872 Property::Map propertyMap;
2873 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2874 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2875 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2877 Dali::Property::Map visualMap;
2878 colorVisual.CreatePropertyMap(visualMap);
2879 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2880 Dali::Property::Map* map = value->GetMap();
2881 DALI_TEST_CHECK(map);
2883 //Test default values
2885 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2886 DALI_TEST_CHECK(typeValue);
2887 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2890 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2891 DALI_TEST_CHECK(typeValue);
2892 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2895 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2896 DALI_TEST_CHECK(typeValue);
2897 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2900 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2901 DALI_TEST_CHECK(typeValue);
2902 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2905 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2906 DALI_TEST_CHECK(typeValue);
2907 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2910 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2911 DALI_TEST_CHECK(typeValue);
2912 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2915 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2916 DALI_TEST_CHECK(typeValue);
2917 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2923 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2925 Property::Map transform;
2926 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2927 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2928 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2929 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2930 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2931 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2933 visual.SetTransformAndSize(transform, Vector2(100, 100));
2935 Dali::Property::Map visualMap;
2936 visual.CreatePropertyMap(visualMap);
2937 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2938 Dali::Property::Map* map = value->GetMap();
2939 DALI_TEST_CHECK(map);
2942 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2943 DALI_TEST_CHECK(typeValue);
2944 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2947 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2948 DALI_TEST_CHECK(typeValue);
2949 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2952 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2953 DALI_TEST_CHECK(typeValue);
2954 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2957 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2958 DALI_TEST_CHECK(typeValue);
2959 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2962 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2963 DALI_TEST_CHECK(typeValue);
2964 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2967 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2968 DALI_TEST_CHECK(typeValue);
2969 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2972 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2973 DALI_TEST_CHECK(typeValue);
2974 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2977 //Put the visual on the stage
2978 DummyControl actor = DummyControl::New(true);
2979 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2980 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2981 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2982 application.GetScene().Add(actor);
2984 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2985 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2987 application.SendNotification();
2988 application.Render(0);
2989 Renderer renderer(actor.GetRendererAt(0));
2991 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2992 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2994 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2995 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2997 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2998 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
3000 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3001 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
3003 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3004 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3006 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3007 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
3009 //Set a new transform
3011 transform = DefaultTransform();
3012 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
3013 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
3014 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
3015 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
3016 visual.SetTransformAndSize(transform, Vector2(100, 100));
3017 application.SendNotification();
3018 application.Render(0);
3020 //Check that the values have changed in the renderer
3021 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
3022 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
3024 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
3025 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
3027 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
3028 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
3030 //Parent origin and anchor point should have the default values
3031 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
3032 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
3034 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
3035 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
3037 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3038 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
3041 int UtcDaliVisualSetTransform01(void)
3043 ToolkitTestApplication application;
3044 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3046 VisualFactory factory = VisualFactory::Get();
3047 Property::Map propertyMap;
3048 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3049 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
3050 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3051 Visual::Base visual = factory.CreateVisual(propertyMap);
3052 TestTransform(application, visual);
3053 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3058 int UtcDaliVisualSetTransform0(void)
3060 ToolkitTestApplication application;
3061 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3063 VisualFactory factory = VisualFactory::Get();
3064 Property::Map propertyMap;
3065 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3066 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3067 Visual::Base visual = factory.CreateVisual(propertyMap);
3068 TestTransform(application, visual);
3069 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3074 int UtcDaliVisualSetTransform1(void)
3076 ToolkitTestApplication application;
3077 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3079 VisualFactory factory = VisualFactory::Get();
3080 Property::Map propertyMap;
3081 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3082 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3083 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3084 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3085 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3086 Visual::Base visual = factory.CreateVisual(propertyMap);
3087 TestTransform(application, visual);
3088 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3093 int UtcDaliVisualSetTransform2(void)
3095 ToolkitTestApplication application;
3096 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3098 VisualFactory factory = VisualFactory::Get();
3099 Property::Map propertyMap;
3100 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3101 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3103 Property::Array stopOffsets;
3104 stopOffsets.PushBack(0.0f);
3105 stopOffsets.PushBack(0.3f);
3106 stopOffsets.PushBack(0.6f);
3107 stopOffsets.PushBack(0.8f);
3108 stopOffsets.PushBack(1.0f);
3109 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3111 Property::Array stopColors;
3112 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3113 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3114 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3115 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3116 stopColors.PushBack(Color::YELLOW);
3117 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3118 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3119 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3120 Visual::Base visual = factory.CreateVisual(propertyMap);
3121 TestTransform(application, visual);
3122 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3127 int UtcDaliVisualSetTransform3(void)
3129 ToolkitTestApplication application;
3130 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3132 VisualFactory factory = VisualFactory::Get();
3133 Property::Map propertyMap;
3134 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3135 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3136 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3137 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3138 Visual::Base visual = factory.CreateVisual(propertyMap);
3139 TestTransform(application, visual);
3140 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3145 int UtcDaliVisualSetTransform4(void)
3147 ToolkitTestApplication application;
3148 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3150 VisualFactory factory = VisualFactory::Get();
3151 Property::Map propertyMap;
3152 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3153 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3155 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3156 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3157 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3158 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3159 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3160 Visual::Base visual = factory.CreateVisual(propertyMap);
3161 TestTransform(application, visual);
3162 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3167 int UtcDaliVisualSetTransform5(void)
3169 ToolkitTestApplication application;
3170 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3172 VisualFactory factory = VisualFactory::Get();
3173 Property::Map propertyMap;
3174 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3175 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3176 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3177 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3178 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3179 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3180 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3181 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3182 Visual::Base visual = factory.CreateVisual(propertyMap);
3183 TestTransform(application, visual);
3184 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3189 int UtcDaliVisualSetTransform6(void)
3191 ToolkitTestApplication application;
3192 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3194 VisualFactory factory = VisualFactory::Get();
3195 Property::Map propertyMap;
3196 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3197 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3198 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3199 Visual::Base visual = factory.CreateVisual(propertyMap);
3200 TestTransform(application, visual);
3201 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3206 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3208 ToolkitTestApplication application;
3209 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3211 VisualFactory factory = VisualFactory::Get();
3212 Property::Map propertyMap;
3213 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3214 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3215 Visual::Base visual = factory.CreateVisual(propertyMap);
3217 Property::Map transform;
3218 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3219 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3220 visual.SetTransformAndSize(transform, Vector2(100, 100));
3222 Dali::Property::Map visualMap;
3223 visual.CreatePropertyMap(visualMap);
3224 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3225 Dali::Property::Map* map = value->GetMap();
3226 DALI_TEST_CHECK(map);
3229 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3230 DALI_TEST_CHECK(typeValue);
3231 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3234 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3235 DALI_TEST_CHECK(typeValue);
3236 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3242 int UtcDaliNPatchVisualCustomShader(void)
3244 ToolkitTestApplication application;
3245 tet_infoline("NPatchVisual with custom shader");
3247 VisualFactory factory = VisualFactory::Get();
3248 Property::Map properties;
3249 Property::Map shader;
3250 const std::string vertexShader = "Foobar";
3251 const std::string fragmentShader = "Foobar";
3252 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3253 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3255 Property::Map transformMap;
3256 transformMap["size"] = Vector2(0.5f, 0.5f);
3257 transformMap["offset"] = Vector2(20.0f, 0.0f);
3258 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3259 transformMap["anchorPoint"] = Align::CENTER;
3260 transformMap["origin"] = Align::CENTER;
3261 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3262 properties[Visual::Property::TRANSFORM] = transformMap;
3264 properties[Visual::Property::TYPE] = Visual::IMAGE;
3265 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3266 properties[Visual::Property::SHADER] = shader;
3267 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3268 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3270 Visual::Base visual = factory.CreateVisual(properties);
3271 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3273 // trigger creation through setting on stage
3274 DummyControl dummy = DummyControl::New(true);
3275 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3276 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3277 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3278 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3279 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3280 application.GetScene().Add(dummy);
3281 application.SendNotification();
3283 Renderer renderer = dummy.GetRendererAt(0);
3284 Shader shader2 = renderer.GetShader();
3285 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3286 Property::Map* map = value.GetMap();
3287 DALI_TEST_CHECK(map);
3289 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3290 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3292 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3293 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3295 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3296 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3298 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3299 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3304 int UtcDaliGradientVisualBlendMode(void)
3306 ToolkitTestApplication application;
3307 VisualFactory factory = VisualFactory::Get();
3309 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3310 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)));
3312 Visual::Base alphaGradientVisual = factory.CreateVisual(
3313 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))));
3315 DummyControl control = DummyControl::New(true);
3316 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3317 application.GetScene().Add(control);
3319 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3320 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3321 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3323 application.SendNotification();
3324 application.Render();
3326 // 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
3327 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3328 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3329 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3334 int UtcDaliVisualRendererRemovalAndReAddition(void)
3336 ToolkitTestApplication application;
3337 tet_infoline("UtcDaliVisualRendererRemoval");
3339 VisualFactory factory = VisualFactory::Get();
3340 Property::Map propertyMap;
3341 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3342 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3343 Visual::Base visual = factory.CreateVisual(propertyMap);
3345 visual.SetDepthIndex(1);
3347 DummyControl dummyControl = DummyControl::New(true);
3348 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3349 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3350 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3352 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3353 tet_infoline("Add control with visual to stage and check renderer count is 1");
3355 application.GetScene().Add(dummyControl);
3357 application.SendNotification();
3358 application.Render();
3360 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3362 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3363 application.GetScene().Remove(dummyControl);
3364 application.SendNotification();
3365 application.Render();
3367 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3369 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3371 application.GetScene().Add(dummyControl);
3373 application.SendNotification();
3374 application.Render();
3376 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3381 int UtcDaliVisualTextVisualRender(void)
3383 ToolkitTestApplication application;
3384 tet_infoline("UtcDaliVisualTextVisualRender");
3386 VisualFactory factory = VisualFactory::Get();
3387 Property::Map propertyMap;
3388 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3389 propertyMap.Insert("mixColor", Color::WHITE);
3390 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3391 propertyMap.Insert("enableMarkup", false);
3392 propertyMap.Insert("text", "Hello world");
3393 propertyMap.Insert("fontFamily", "TizenSans");
3395 Property::Map fontStyleMapSet;
3396 fontStyleMapSet.Insert("weight", "bold");
3397 propertyMap.Insert("fontStyle", fontStyleMapSet);
3399 propertyMap.Insert("pointSize", 12.f);
3400 propertyMap.Insert("multiLine", true);
3401 propertyMap.Insert("horizontalAlignment", "CENTER");
3402 propertyMap.Insert("verticalAlignment", "CENTER");
3403 propertyMap.Insert("textColor", Color::RED);
3404 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3405 textVisual.SetDepthIndex(1);
3407 DummyControl dummyControl = DummyControl::New(true);
3408 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3409 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3410 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3412 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3413 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3415 application.GetScene().Add(dummyControl);
3416 application.SendNotification();
3417 application.Render();
3419 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3420 propertyMap.Clear();
3421 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3422 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3423 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3424 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3426 Property::Map transformMap;
3427 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3428 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3430 textVisual = factory.CreateVisual(propertyMap);
3431 textVisual.SetDepthIndex(1);
3433 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3434 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3436 application.SendNotification(); // force process events to ensure text visual
3437 // adds renderer to the dummy control in OnRelayout
3438 application.Render();
3440 Renderer renderer = dummyControl.GetRendererAt(0u);
3441 Property::Index index = renderer.GetPropertyIndex("transformSize");
3443 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3444 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3449 int UtcDaliVisualTextVisualDisableEnable(void)
3451 ToolkitTestApplication application;
3452 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3454 VisualFactory factory = VisualFactory::Get();
3455 Property::Map propertyMap;
3456 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3457 propertyMap.Insert("mixColor", Color::WHITE);
3458 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3459 propertyMap.Insert("enableMarkup", false);
3460 propertyMap.Insert("text", "Hello world");
3461 propertyMap.Insert("fontFamily", "TizenSans");
3463 Property::Map fontStyleMapSet;
3464 fontStyleMapSet.Insert("weight", "bold");
3465 propertyMap.Insert("fontStyle", fontStyleMapSet);
3467 propertyMap.Insert("pointSize", 12.f);
3468 propertyMap.Insert("multiLine", true);
3469 propertyMap.Insert("horizontalAlignment", "CENTER");
3470 propertyMap.Insert("verticalAlignment", "CENTER");
3471 propertyMap.Insert("textColor", Color::RED);
3472 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3473 textVisual.SetDepthIndex(1);
3475 DummyControl dummyControl = DummyControl::New(true);
3476 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3477 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3478 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3480 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3481 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3483 application.GetScene().Add(dummyControl);
3484 application.SendNotification();
3485 application.Render();
3487 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3489 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3491 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3493 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3495 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3500 int UtcDaliVisualPremultipliedAlpha(void)
3502 ToolkitTestApplication application;
3503 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3505 VisualFactory factory = VisualFactory::Get();
3507 // image visual, test default value ( true )
3509 Visual::Base imageVisual = factory.CreateVisual(
3511 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3512 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3514 Dali::Property::Map visualMap;
3515 imageVisual.CreatePropertyMap(visualMap);
3516 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3519 DALI_TEST_CHECK(value);
3520 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3523 // image visual, override premultiplied
3525 Visual::Base imageVisual = factory.CreateVisual(
3527 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3528 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3529 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3531 Dali::Property::Map visualMap;
3532 imageVisual.CreatePropertyMap(visualMap);
3533 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3536 DALI_TEST_CHECK(value);
3537 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3540 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3542 Visual::Base imageVisual = factory.CreateVisual(
3544 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3545 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3547 Dali::Property::Map visualMap;
3548 imageVisual.CreatePropertyMap(visualMap);
3549 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3552 DALI_TEST_CHECK(value);
3553 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3556 Visual::Base imageVisual = factory.CreateVisual(
3558 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3559 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3560 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3562 Dali::Property::Map visualMap;
3563 imageVisual.CreatePropertyMap(visualMap);
3564 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3567 DALI_TEST_CHECK(value);
3568 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3571 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3573 Visual::Base imageVisual = factory.CreateVisual(
3575 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3576 .Add(ImageVisual::Property::URL, "something.json"));
3578 Dali::Property::Map visualMap;
3579 imageVisual.CreatePropertyMap(visualMap);
3580 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3583 DALI_TEST_CHECK(value);
3584 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3587 Visual::Base imageVisual = factory.CreateVisual(
3589 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3590 .Add(ImageVisual::Property::URL, "something.json")
3591 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3593 Dali::Property::Map visualMap;
3594 imageVisual.CreatePropertyMap(visualMap);
3595 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3598 DALI_TEST_CHECK(value);
3599 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3602 // text visual ( premultiplied alpha by default is true, and cannot change value )
3604 Visual::Base textVisual = factory.CreateVisual(
3606 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3607 .Add(TextVisual::Property::TEXT, "Text"));
3609 Dali::Property::Map visualMap;
3610 textVisual.CreatePropertyMap(visualMap);
3611 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3614 DALI_TEST_CHECK(value);
3615 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3618 Visual::Base textVisual = factory.CreateVisual(
3620 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3621 .Add(TextVisual::Property::TEXT, "Text")
3622 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3624 Dali::Property::Map visualMap;
3625 textVisual.CreatePropertyMap(visualMap);
3626 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3629 DALI_TEST_CHECK(value);
3630 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3633 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3635 Visual::Base gradientVisual = factory.CreateVisual(
3637 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3638 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3639 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3640 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3642 Dali::Property::Map visualMap;
3643 gradientVisual.CreatePropertyMap(visualMap);
3644 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3647 DALI_TEST_CHECK(value);
3648 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3651 Visual::Base gradientVisual = factory.CreateVisual(
3653 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3654 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3655 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3656 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3657 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3659 Dali::Property::Map visualMap;
3660 gradientVisual.CreatePropertyMap(visualMap);
3661 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3664 DALI_TEST_CHECK(value);
3665 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3668 // color visual ( premultiplied alpha by default is false, and cannot change value )
3670 Visual::Base colorVisual = factory.CreateVisual(
3672 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3673 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3675 Dali::Property::Map visualMap;
3676 colorVisual.CreatePropertyMap(visualMap);
3677 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3680 DALI_TEST_CHECK(value);
3681 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3684 Visual::Base colorVisual = factory.CreateVisual(
3686 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3687 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3688 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3690 Dali::Property::Map visualMap;
3691 colorVisual.CreatePropertyMap(visualMap);
3692 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3695 DALI_TEST_CHECK(value);
3696 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3702 int UtcDaliRegisterVisualOrder(void)
3704 ToolkitTestApplication application;
3705 tet_infoline("Register Visual Order");
3707 DummyControl dummyControl = DummyControl::New(true);
3708 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3710 VisualFactory factory = VisualFactory::Get();
3711 Property::Map propertyMap;
3712 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3713 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3715 tet_infoline("Register visual, should have depth index of 0.0f");
3716 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3717 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3718 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3720 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3722 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3723 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3724 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3726 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3727 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3728 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3730 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3731 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3732 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3734 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3735 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3736 labelVisual.SetDepthIndex(-2000);
3737 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3738 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3740 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3741 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3742 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3743 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3744 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3745 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3747 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3748 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3749 anotherTestVisual2Replacement.SetDepthIndex(2000);
3750 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3751 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3753 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3754 application.GetScene().Add(dummyControl);
3759 int UtcDaliRegisterVisualOrder02(void)
3761 ToolkitTestApplication application;
3762 tet_infoline("Register Visual Order with Background Set");
3764 DummyControl dummyControl = DummyControl::New(true);
3765 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3767 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3769 VisualFactory factory = VisualFactory::Get();
3770 Property::Map propertyMap;
3771 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3772 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3774 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3776 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3778 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3779 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3780 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3781 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3782 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3784 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3785 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3786 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3787 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3789 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3790 application.GetScene().Add(dummyControl);
3795 int UtcDaliRegisterVisualWithDepthIndex(void)
3797 ToolkitTestApplication application;
3798 tet_infoline("Register a Visual With Depth Index");
3800 DummyControl dummyControl = DummyControl::New(true);
3801 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3803 VisualFactory factory = VisualFactory::Get();
3804 Property::Map propertyMap;
3805 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3806 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3808 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3809 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3810 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3811 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3812 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3814 tet_infoline("Register another visual with a depth index and it disabled");
3815 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3816 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3817 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3818 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3820 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3821 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3822 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3823 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3824 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3826 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3827 application.GetScene().Add(dummyControl);
3832 int UtcDaliSvgVisualCustomShader(void)
3834 ToolkitTestApplication application;
3835 tet_infoline("SvgVisual with custom shader");
3837 VisualFactory factory = VisualFactory::Get();
3838 Property::Map properties;
3839 Property::Map shader;
3840 const std::string vertexShader = "Foobar";
3841 const std::string fragmentShader = "Foobar";
3842 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3843 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3845 properties[Visual::Property::TYPE] = Visual::IMAGE;
3846 properties[Visual::Property::SHADER] = shader;
3847 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3849 Visual::Base visual = factory.CreateVisual(properties);
3851 // trigger creation through setting on stage
3852 DummyControl dummy = DummyControl::New(true);
3853 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3854 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3856 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3857 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3858 application.GetScene().Add(dummy);
3860 application.SendNotification();
3861 application.Render();
3863 // Wait for loading & rasterization
3864 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3866 Renderer renderer = dummy.GetRendererAt(0);
3867 Shader shader2 = renderer.GetShader();
3868 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3869 Property::Map* map = value.GetMap();
3870 DALI_TEST_CHECK(map);
3872 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3873 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3875 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3876 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3881 int UtcDaliVisualRoundedCorner(void)
3883 tet_infoline("UtcDaliVisualRoundedCorner");
3885 static std::vector<UniformData> customUniforms =
3887 UniformData("cornerRadius", Property::Type::VECTOR4),
3888 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3893 ToolkitTestApplication application;
3894 TestGraphicsController& graphics = application.GetGraphicsController();
3895 graphics.AddCustomUniforms(customUniforms);
3897 VisualFactory factory = VisualFactory::Get();
3898 Property::Map properties;
3899 float cornerRadius = 30.0f;
3901 properties[Visual::Property::TYPE] = Visual::IMAGE;
3902 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3903 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3905 Visual::Base visual = factory.CreateVisual(properties);
3907 // trigger creation through setting on stage
3908 DummyControl dummy = DummyControl::New(true);
3909 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3910 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3912 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3913 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3914 application.GetScene().Add(dummy);
3916 application.SendNotification();
3917 application.Render();
3919 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3921 application.SendNotification();
3922 application.Render();
3924 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3925 // Default corner radius policy is absolute.
3926 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3931 ToolkitTestApplication application;
3932 TestGraphicsController& graphics = application.GetGraphicsController();
3933 graphics.AddCustomUniforms(customUniforms);
3935 VisualFactory factory = VisualFactory::Get();
3936 Property::Map properties;
3937 float cornerRadius = 30.0f;
3939 properties[Visual::Property::TYPE] = Visual::COLOR;
3940 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3941 properties["cornerRadius"] = cornerRadius;
3942 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3944 Visual::Base visual = factory.CreateVisual(properties);
3946 // trigger creation through setting on stage
3947 DummyControl dummy = DummyControl::New(true);
3948 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3949 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3951 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3952 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3953 application.GetScene().Add(dummy);
3955 application.SendNotification();
3956 application.Render();
3958 application.SendNotification();
3959 application.Render();
3961 // Currently test with multiple program doesn't work well. will fix another day
3962 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3963 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3968 ToolkitTestApplication application;
3969 TestGraphicsController& graphics = application.GetGraphicsController();
3970 graphics.AddCustomUniforms(customUniforms);
3972 VisualFactory factory = VisualFactory::Get();
3973 Property::Map properties;
3974 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3976 properties[Visual::Property::TYPE] = Visual::COLOR;
3977 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3978 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3979 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3981 Visual::Base visual = factory.CreateVisual(properties);
3983 // trigger creation through setting on stage
3984 DummyControl dummy = DummyControl::New(true);
3985 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3986 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3988 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3989 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3990 application.GetScene().Add(dummy);
3992 application.SendNotification();
3993 application.Render();
3995 application.SendNotification();
3996 application.Render();
3998 // Currently test with multiple program doesn't work well. will fix another day
3999 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4000 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4003 // color visual 3 - invalid value
4005 ToolkitTestApplication application;
4006 TestGraphicsController& graphics = application.GetGraphicsController();
4007 graphics.AddCustomUniforms(customUniforms);
4009 VisualFactory factory = VisualFactory::Get();
4010 Property::Map properties;
4011 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
4013 properties[Visual::Property::TYPE] = Visual::COLOR;
4014 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4015 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4016 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
4018 Visual::Base visual = factory.CreateVisual(properties);
4020 // trigger creation through setting on stage
4021 DummyControl dummy = DummyControl::New(true);
4022 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4023 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4025 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4026 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4027 application.GetScene().Add(dummy);
4029 application.SendNotification();
4030 application.Render();
4032 application.SendNotification();
4033 application.Render();
4035 // Currently test with multiple program doesn't work well. will fix another day
4036 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4037 // Default corner radius policy is absolute.
4038 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4043 ToolkitTestApplication application;
4044 TestGraphicsController& graphics = application.GetGraphicsController();
4045 graphics.AddCustomUniforms(customUniforms);
4047 VisualFactory factory = VisualFactory::Get();
4048 Property::Map properties;
4049 float cornerRadius = 30.0f;
4051 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4052 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4053 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4054 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4055 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4056 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4058 Property::Array stopOffsets;
4059 stopOffsets.PushBack(0.0f);
4060 stopOffsets.PushBack(0.6f);
4061 stopOffsets.PushBack(1.0f);
4062 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4064 Property::Array stopColors;
4065 stopColors.PushBack(Color::RED);
4066 stopColors.PushBack(Color::YELLOW);
4067 stopColors.PushBack(Color::GREEN);
4068 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4070 Visual::Base visual = factory.CreateVisual(properties);
4072 // trigger creation through setting on stage
4073 DummyControl dummy = DummyControl::New(true);
4074 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4075 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4077 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4078 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4079 application.GetScene().Add(dummy);
4081 application.SendNotification();
4082 application.Render();
4084 application.SendNotification();
4085 application.Render();
4087 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4088 // Default corner radius policy is absolute.
4089 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4092 // animated image visual
4094 ToolkitTestApplication application;
4095 TestGraphicsController& graphics = application.GetGraphicsController();
4096 graphics.AddCustomUniforms(customUniforms);
4098 VisualFactory factory = VisualFactory::Get();
4099 Property::Map properties;
4100 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4102 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4103 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4104 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4105 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4106 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4108 Visual::Base visual = factory.CreateVisual(properties);
4110 // trigger creation through setting on stage
4111 DummyControl dummy = DummyControl::New(true);
4112 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4113 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4115 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4116 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4117 application.GetScene().Add(dummy);
4119 application.SendNotification();
4120 application.Render();
4122 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4124 application.SendNotification();
4125 application.Render();
4127 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4128 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4131 // vector image visual
4133 ToolkitTestApplication application;
4134 TestGraphicsController& graphics = application.GetGraphicsController();
4135 graphics.AddCustomUniforms(customUniforms);
4137 VisualFactory factory = VisualFactory::Get();
4138 Property::Map properties;
4139 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4141 properties[Visual::Property::TYPE] = Visual::SVG;
4142 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4143 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4145 Visual::Base visual = factory.CreateVisual(properties);
4147 // trigger creation through setting on stage
4148 DummyControl dummy = DummyControl::New(true);
4149 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4150 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4152 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4153 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4154 application.GetScene().Add(dummy);
4156 application.SendNotification();
4157 application.Render();
4159 // Wait for loading & rasterization
4160 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4162 application.SendNotification();
4163 application.Render();
4165 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4166 // Default corner radius policy is absolute.
4167 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4170 // animated vector image visual
4172 ToolkitTestApplication application;
4173 TestGraphicsController& graphics = application.GetGraphicsController();
4174 graphics.AddCustomUniforms(customUniforms);
4176 VisualFactory factory = VisualFactory::Get();
4177 Property::Map properties;
4178 float cornerRadius = 1.3f;
4180 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4181 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4182 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4183 properties["cornerRadius"] = cornerRadius;
4184 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4186 Visual::Base visual = factory.CreateVisual(properties);
4188 // trigger creation through setting on stage
4189 DummyControl dummy = DummyControl::New(true);
4190 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4191 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4193 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4194 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4195 application.GetScene().Add(dummy);
4197 application.SendNotification();
4198 application.Render();
4200 // Trigger count is 2 - load & render a frame
4201 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4203 application.SendNotification();
4204 application.Render();
4206 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4207 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4213 int UtcDaliVisualBorderline(void)
4215 tet_infoline("UtcDaliVisualBorderline");
4217 static std::vector<UniformData> customUniforms =
4219 UniformData("cornerRadius", Property::Type::VECTOR4),
4220 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4221 UniformData("borderlineWidth", Property::Type::FLOAT),
4222 UniformData("borderlineColor", Property::Type::VECTOR4),
4223 UniformData("borderlineOffset", Property::Type::FLOAT),
4228 ToolkitTestApplication application;
4229 TestGraphicsController& graphics = application.GetGraphicsController();
4230 graphics.AddCustomUniforms(customUniforms);
4232 VisualFactory factory = VisualFactory::Get();
4233 Property::Map properties;
4234 float cornerRadius = 5.0f;
4235 float borderlineWidth = 30.0f;
4236 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4237 float borderlineOffset = 1.0f;
4239 properties[Visual::Property::TYPE] = Visual::IMAGE;
4240 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4241 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4242 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4243 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4244 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4246 Visual::Base visual = factory.CreateVisual(properties);
4248 // trigger creation through setting on stage
4249 DummyControl dummy = DummyControl::New(true);
4250 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4251 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4253 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4254 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4255 application.GetScene().Add(dummy);
4257 application.SendNotification();
4258 application.Render();
4260 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4262 application.SendNotification();
4263 application.Render();
4265 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4266 // Default corner radius policy is absolute.
4267 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4268 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4269 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4270 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4275 ToolkitTestApplication application;
4276 TestGraphicsController& graphics = application.GetGraphicsController();
4277 graphics.AddCustomUniforms(customUniforms);
4279 VisualFactory factory = VisualFactory::Get();
4280 Property::Map properties;
4281 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4282 float borderlineWidth = 30.0f;
4283 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4284 float borderlineOffset = -0.4f;
4286 properties[Visual::Property::TYPE] = Visual::COLOR;
4287 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4288 properties["cornerRadius"] = cornerRadius;
4289 properties["borderlineWidth"] = borderlineWidth;
4290 properties["borderlineColor"] = borderlineColor;
4291 properties["borderlineOffset"] = borderlineOffset;
4293 Visual::Base visual = factory.CreateVisual(properties);
4295 // trigger creation through setting on stage
4296 DummyControl dummy = DummyControl::New(true);
4297 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4298 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4300 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4301 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4302 application.GetScene().Add(dummy);
4304 application.SendNotification();
4305 application.Render();
4307 application.SendNotification();
4308 application.Render();
4310 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4311 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4312 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4313 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4316 // color visual 2, default color, default offset
4318 ToolkitTestApplication application;
4319 TestGraphicsController& graphics = application.GetGraphicsController();
4320 graphics.AddCustomUniforms(customUniforms);
4322 VisualFactory factory = VisualFactory::Get();
4323 Property::Map properties;
4324 float borderlineWidth = 30.0f;
4326 properties[Visual::Property::TYPE] = Visual::COLOR;
4327 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4328 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4330 Visual::Base visual = factory.CreateVisual(properties);
4332 // trigger creation through setting on stage
4333 DummyControl dummy = DummyControl::New(true);
4334 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4335 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4337 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4338 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4339 application.GetScene().Add(dummy);
4341 application.SendNotification();
4342 application.Render();
4344 application.SendNotification();
4345 application.Render();
4347 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4348 // Default borderline color is BLACK.
4349 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4350 // Default borderline offset is 0.0f.
4351 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4354 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4356 ToolkitTestApplication application;
4357 TestGraphicsController& graphics = application.GetGraphicsController();
4358 graphics.AddCustomUniforms(customUniforms);
4360 VisualFactory factory = VisualFactory::Get();
4361 Property::Map properties;
4362 float borderlineWidth = 30.0f;
4363 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4364 float borderlineOffset = 37.4f;
4366 properties[Visual::Property::TYPE] = Visual::COLOR;
4367 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4368 properties["borderlineWidth"] = borderlineWidth;
4369 properties["borderlineColor"] = borderlineColor;
4370 properties["borderlineOffset"] = borderlineOffset;
4372 Visual::Base visual = factory.CreateVisual(properties);
4374 // trigger creation through setting on stage
4375 DummyControl dummy = DummyControl::New(true);
4376 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4377 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4379 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4380 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4381 application.GetScene().Add(dummy);
4383 application.SendNotification();
4384 application.Render();
4386 application.SendNotification();
4387 application.Render();
4389 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4390 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4391 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4392 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4397 ToolkitTestApplication application;
4398 TestGraphicsController& graphics = application.GetGraphicsController();
4399 graphics.AddCustomUniforms(customUniforms);
4401 VisualFactory factory = VisualFactory::Get();
4402 Property::Map properties;
4403 float borderlineWidth = 30.0f;
4404 float cornerRadius = 70.0f;
4406 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4407 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4408 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4409 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4410 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4411 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4412 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4414 Property::Array stopOffsets;
4415 stopOffsets.PushBack(0.0f);
4416 stopOffsets.PushBack(0.6f);
4417 stopOffsets.PushBack(1.0f);
4418 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4420 Property::Array stopColors;
4421 stopColors.PushBack(Color::RED);
4422 stopColors.PushBack(Color::YELLOW);
4423 stopColors.PushBack(Color::GREEN);
4424 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4426 Visual::Base visual = factory.CreateVisual(properties);
4428 // trigger creation through setting on stage
4429 DummyControl dummy = DummyControl::New(true);
4430 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4431 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4433 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4434 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4435 application.GetScene().Add(dummy);
4437 application.SendNotification();
4438 application.Render();
4440 application.SendNotification();
4441 application.Render();
4443 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4444 // Default corner radius policy is absolute.
4445 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4446 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4447 // Default borderline color is BLACK.
4448 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4449 // Default borderline offset is 0.0f.
4450 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4453 // animated image visual
4455 ToolkitTestApplication application;
4456 TestGraphicsController& graphics = application.GetGraphicsController();
4457 graphics.AddCustomUniforms(customUniforms);
4459 VisualFactory factory = VisualFactory::Get();
4460 Property::Map properties;
4461 float borderlineWidth = 24.0f;
4462 float borderlineOffset = -1.0f;
4464 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4465 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4466 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4467 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4468 properties["borderlineOffset"] = borderlineOffset;
4470 Visual::Base visual = factory.CreateVisual(properties);
4472 // trigger creation through setting on stage
4473 DummyControl dummy = DummyControl::New(true);
4474 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4475 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4477 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4478 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4479 application.GetScene().Add(dummy);
4481 application.SendNotification();
4482 application.Render();
4484 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4486 application.SendNotification();
4487 application.Render();
4489 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4490 // Default borderline color is BLACK.
4491 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4492 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4495 // vector image visual
4497 ToolkitTestApplication application;
4498 TestGraphicsController& graphics = application.GetGraphicsController();
4499 graphics.AddCustomUniforms(customUniforms);
4501 VisualFactory factory = VisualFactory::Get();
4502 Property::Map properties;
4503 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4504 float borderlineWidth = 27.0f;
4505 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4507 properties[Visual::Property::TYPE] = Visual::SVG;
4508 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4509 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4510 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4511 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4513 Visual::Base visual = factory.CreateVisual(properties);
4515 // trigger creation through setting on stage
4516 DummyControl dummy = DummyControl::New(true);
4517 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4518 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4520 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4521 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4522 application.GetScene().Add(dummy);
4524 application.SendNotification();
4525 application.Render();
4527 // Wait for loading & rasterization
4528 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4530 application.SendNotification();
4531 application.Render();
4533 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4534 // Default corner radius policy is absolute.
4535 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4536 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4537 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4538 // Default borderline offset is 0.0.
4539 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4542 // animated vector image visual
4544 ToolkitTestApplication application;
4545 TestGraphicsController& graphics = application.GetGraphicsController();
4546 graphics.AddCustomUniforms(customUniforms);
4548 VisualFactory factory = VisualFactory::Get();
4549 Property::Map properties;
4550 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4551 float borderlineWidth = 13.0f;
4552 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4553 float borderlineOffset = 13.0f;
4555 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4556 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4557 properties["cornerRadius"] = cornerRadius;
4558 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4559 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4560 properties["borderlineColor"] = borderlineColor;
4561 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4563 Visual::Base visual = factory.CreateVisual(properties);
4565 // trigger creation through setting on stage
4566 DummyControl dummy = DummyControl::New(true);
4567 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4568 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4570 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4571 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4572 application.GetScene().Add(dummy);
4574 application.SendNotification();
4575 application.Render();
4577 // Trigger count is 2 - load & render a frame
4578 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4580 application.SendNotification();
4581 application.Render();
4583 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4584 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4585 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4586 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4587 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4593 int UtcDaliVisualBorderlineBlendModeTest(void)
4595 ToolkitTestApplication application;
4596 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4597 VisualFactory factory = VisualFactory::Get();
4599 // Case 1 : Test which doesn't support borderline feature.
4601 tet_printf("Test Unsupported visual type\n");
4602 Property::Map propertyMap;
4603 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4604 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4605 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4606 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4608 DummyControl actor = DummyControl::New(true);
4609 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4610 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4611 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4612 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4613 application.GetScene().Add(actor);
4615 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4617 Renderer renderer = actor.GetRendererAt(0);
4619 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4620 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4621 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4623 application.GetScene().Remove(actor);
4626 // Case 2 : Test which support borderline feature.
4628 tet_printf("Test normal case\n");
4629 Property::Map propertyMap;
4630 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4631 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4632 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4633 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4635 DummyControl actor = DummyControl::New(true);
4636 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4637 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4638 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4639 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4640 application.GetScene().Add(actor);
4642 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4644 Renderer renderer = actor.GetRendererAt(0);
4646 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4647 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4648 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4650 application.GetScene().Remove(actor);
4653 // Case 3 : Test which animated borderline.
4655 tet_printf("Test borderline animate case\n");
4656 Property::Map propertyMap;
4657 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4658 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4659 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4661 DummyControl actor = DummyControl::New(true);
4662 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4663 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4664 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4665 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4666 application.GetScene().Add(actor);
4668 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4670 Renderer renderer = actor.GetRendererAt(0);
4672 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4673 // BlendMode is AUTO.
4674 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4676 Animation animation = Animation::New(0.1f);
4677 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4680 application.SendNotification();
4681 application.Render();
4682 application.Render(101u); // End of animation
4684 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4685 // BlendMode is ON_WITHOUT_CULL.
4686 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4688 Animation revanimation = Animation::New(0.1f);
4689 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4690 revanimation.Play();
4692 application.SendNotification();
4693 application.Render();
4694 application.Render(101u); // End of animation
4696 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4697 // BlendMode is still ON_WITHOUT_CULL.
4698 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4700 application.GetScene().Remove(actor);
4703 // Case 4 : Test which animated corner radius occur.
4705 tet_printf("Test borderline animate case\n");
4706 Property::Map propertyMap;
4707 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4708 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4709 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4710 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4712 DummyControl actor = DummyControl::New(true);
4713 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4714 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4715 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4716 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4717 application.GetScene().Add(actor);
4719 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4721 Renderer renderer = actor.GetRendererAt(0);
4723 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4724 // BlendMode is ON_WITHOUT_CULL.
4725 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4727 Animation animation = Animation::New(0.1f);
4728 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4731 application.SendNotification();
4732 application.Render();
4733 application.Render(101u); // End of animation
4735 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4736 // BlendMode is ON_WITHOUT_CULL.
4737 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4739 application.GetScene().Remove(actor);
4745 int UtcDaliVisualBorderlineColorAnimateTest(void)
4747 ToolkitTestApplication application;
4748 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4750 TestGraphicsController& graphics = application.GetGraphicsController();
4751 static std::vector<UniformData> customUniforms =
4753 UniformData("mixColor", Property::Type::VECTOR3),
4754 UniformData("cornerRadius", Property::Type::VECTOR4),
4755 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4756 UniformData("borderlineWidth", Property::Type::FLOAT),
4757 UniformData("borderlineColor", Property::Type::VECTOR4),
4758 UniformData("borderlineOffset", Property::Type::FLOAT),
4760 graphics.AddCustomUniforms(customUniforms);
4763 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4764 const float INITIAL_MIX_OPACITY(0.5f);
4765 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4766 const float INITIAL_ACTOR_OPACITY(1.0f);
4767 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4768 const float TARGET_MIX_OPACITY(0.8f);
4769 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4770 const float TARGET_ACTOR_OPACITY(0.5f);
4772 VisualFactory factory = VisualFactory::Get();
4773 Property::Map propertyMap;
4774 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4775 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4776 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4777 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4778 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4779 Visual::Base visual = factory.CreateVisual(propertyMap);
4781 DummyControl actor = DummyControl::New(true);
4782 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4783 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4784 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4785 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4786 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4787 application.GetScene().Add(actor);
4789 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4791 Animation animation = Animation::New(4.0f);
4792 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4793 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4794 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4795 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4798 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4800 application.SendNotification();
4801 application.Render(0);
4802 application.Render(2000u); // halfway point
4803 application.SendNotification();
4805 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4806 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4807 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4808 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4809 halfwayMixOpacity *= halfwayActorOpacity;
4810 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4811 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4812 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4813 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4815 application.Render(2001u); // go past end
4816 application.SendNotification(); // Trigger signals
4818 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4819 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4820 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4821 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4822 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4830 int UtcDaliColorVisualBlurRadius(void)
4832 ToolkitTestApplication application;
4833 tet_infoline("UtcDaliColorVisualBlurRadius");
4835 static std::vector<UniformData> customUniforms =
4837 UniformData("blurRadius", Property::Type::FLOAT),
4840 TestGraphicsController& graphics = application.GetGraphicsController();
4841 graphics.AddCustomUniforms(customUniforms);
4843 VisualFactory factory = VisualFactory::Get();
4844 Property::Map properties;
4845 float blurRadius = 20.0f;
4847 properties[Visual::Property::TYPE] = Visual::COLOR;
4848 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4849 properties["blurRadius"] = blurRadius;
4851 Visual::Base visual = factory.CreateVisual(properties);
4853 // trigger creation through setting on stage
4854 DummyControl dummy = DummyControl::New(true);
4855 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4856 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4858 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4859 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4860 application.GetScene().Add(dummy);
4862 application.SendNotification();
4863 application.Render();
4865 application.SendNotification();
4866 application.Render();
4868 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4873 int UtcDaliVisualGetType(void)
4875 ToolkitTestApplication application;
4876 tet_infoline("UtcDaliVisualGetType");
4878 VisualFactory factory = VisualFactory::Get();
4881 Property::Map properties;
4882 properties[Visual::Property::TYPE] = Visual::BORDER;
4883 Visual::Base visual = factory.CreateVisual(properties);
4885 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4889 Property::Map properties;
4890 properties[Visual::Property::TYPE] = Visual::COLOR;
4891 Visual::Base visual = factory.CreateVisual(properties);
4893 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4897 Property::Map properties;
4898 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4899 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4900 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4901 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4902 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4903 Property::Array stopColors;
4904 stopColors.PushBack(Color::RED);
4905 stopColors.PushBack(Color::GREEN);
4906 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4907 Visual::Base visual = factory.CreateVisual(properties);
4909 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4913 Property::Map properties;
4914 properties[Visual::Property::TYPE] = Visual::IMAGE;
4915 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4916 Visual::Base visual = factory.CreateVisual(properties);
4918 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4922 Property::Map properties;
4923 properties[Visual::Property::TYPE] = Visual::MESH;
4924 Visual::Base visual = factory.CreateVisual(properties);
4926 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4930 Property::Map properties;
4931 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4932 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4933 Visual::Base visual = factory.CreateVisual(properties);
4935 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4939 Property::Map properties;
4940 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4941 Visual::Base visual = factory.CreateVisual(properties);
4943 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4947 Property::Map properties;
4948 properties[Visual::Property::TYPE] = Visual::TEXT;
4949 Visual::Base visual = factory.CreateVisual(properties);
4951 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4955 Property::Map properties;
4956 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4957 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4958 Visual::Base visual = factory.CreateVisual(properties);
4960 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4964 Property::Map properties;
4965 properties[Visual::Property::TYPE] = Visual::SVG;
4966 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4967 Visual::Base visual = factory.CreateVisual(properties);
4969 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4973 Property::Map properties;
4974 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4975 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4976 Visual::Base visual = factory.CreateVisual(properties);
4978 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4982 Property::Map properties;
4983 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4984 Visual::Base visual = factory.CreateVisual(properties);
4986 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4990 Property::Map properties;
4991 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4992 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4993 Visual::Base visual = factory.CreateVisual(properties);
4995 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4999 Property::Map properties;
5000 properties[Visual::Property::TYPE] = DevelVisual::ARC;
5001 Visual::Base visual = factory.CreateVisual(properties);
5003 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
5009 int UtcDaliVisualGetVisualProperty01(void)
5011 ToolkitTestApplication application;
5012 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
5014 static std::vector<UniformData> customUniforms =
5016 UniformData("mixColor", Property::Type::VECTOR3),
5017 UniformData("offset", Property::Type::VECTOR2),
5018 UniformData("size", Property::Type::VECTOR2),
5019 UniformData("cornerRadius", Property::Type::VECTOR4),
5020 UniformData("blurRadius", Property::Type::FLOAT),
5021 UniformData("borderlineWidth", Property::Type::FLOAT),
5022 UniformData("borderlineColor", Property::Type::VECTOR4),
5023 UniformData("borderlineOffset", Property::Type::FLOAT)};
5025 TestGraphicsController& graphics = application.GetGraphicsController();
5026 graphics.AddCustomUniforms(customUniforms);
5028 VisualFactory factory = VisualFactory::Get();
5029 Property::Map propertyMap;
5030 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5031 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
5032 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
5033 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
5034 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
5035 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
5036 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
5037 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
5038 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5040 DummyControl dummyControl = DummyControl::New(true);
5041 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5042 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5043 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5044 application.GetScene().Add(dummyControl);
5046 application.SendNotification();
5047 application.Render();
5049 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5050 Vector2 targetOffset(0.05f, 0.05f);
5051 Vector2 targetSize(1.1f, 1.1f);
5052 float targetOpacity = 0.5f;
5053 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
5054 float targetBlurRadius = 10.0f;
5055 float targetBorderlineWidth = 25.0f;
5056 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
5057 float targetBorderlineOffset = -1.0f;
5059 Animation animation = Animation::New(1.0f);
5060 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
5061 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5062 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5063 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5064 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5065 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5066 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5067 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5068 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5071 application.SendNotification();
5072 application.Render();
5073 application.Render(1001u); // End of animation
5075 Property::Map resultMap;
5076 colorVisual.CreatePropertyMap(resultMap);
5078 // Test property values: they should be updated
5079 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5080 DALI_TEST_CHECK(colorValue);
5081 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5083 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5084 Dali::Property::Map* transformMap = transformValue->GetMap();
5085 DALI_TEST_CHECK(transformMap);
5087 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5088 DALI_TEST_CHECK(offsetValue);
5089 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5091 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5092 DALI_TEST_CHECK(sizeValue);
5093 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5095 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5096 DALI_TEST_CHECK(cornerRadiusValue);
5097 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5099 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5100 DALI_TEST_CHECK(blurRadiusValue);
5101 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5103 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5104 DALI_TEST_CHECK(borderlineWidthValue);
5105 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5107 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5108 DALI_TEST_CHECK(borderlineColorValue);
5109 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5111 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5112 DALI_TEST_CHECK(borderlineOffsetValue);
5113 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5115 // Test uniform values
5116 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5117 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5118 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5119 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5120 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5121 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5122 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5123 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5125 // Test unregistered visual
5126 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5127 DALI_TEST_CHECK(!property3.object);
5128 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5133 int UtcDaliVisualGetVisualProperty02(void)
5135 ToolkitTestApplication application;
5136 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5138 static std::vector<UniformData> customUniforms =
5140 UniformData("mixColor", Property::Type::VECTOR3),
5141 UniformData("offset", Property::Type::VECTOR2),
5142 UniformData("size", Property::Type::VECTOR2),
5143 UniformData("cornerRadius", Property::Type::VECTOR4),
5144 UniformData("borderlineWidth", Property::Type::FLOAT),
5145 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5146 UniformData("borderlineOffset", Property::Type::FLOAT),
5147 UniformData("blurRadius", Property::Type::FLOAT),
5150 TestGraphicsController& graphics = application.GetGraphicsController();
5151 graphics.AddCustomUniforms(customUniforms);
5153 VisualFactory factory = VisualFactory::Get();
5154 Property::Map propertyMap;
5155 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5156 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5158 DummyControl dummyControl = DummyControl::New(true);
5159 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5160 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5161 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5162 application.GetScene().Add(dummyControl);
5164 application.SendNotification();
5165 application.Render();
5167 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5168 Vector2 targetOffset(0.05f, 0.05f);
5169 Vector2 targetSize(1.1f, 1.1f);
5170 float targetOpacity = 0.5f;
5171 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5172 float targetBorderlineWidth = 77.7f;
5173 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5174 float targetBorderlineOffset = 1.0f;
5175 float targetBlurRadius = 10.0f;
5177 // Should work when the properties are not set before
5178 Animation animation = Animation::New(1.0f);
5179 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5180 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5181 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5182 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5183 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5184 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5185 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5186 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5187 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5190 application.SendNotification();
5191 application.Render();
5192 application.Render(1001u); // End of animation
5194 Property::Map resultMap;
5195 colorVisual.CreatePropertyMap(resultMap);
5197 // Test property values: they should be updated
5198 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5199 DALI_TEST_CHECK(colorValue);
5200 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5202 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5203 Dali::Property::Map* transformMap = transformValue->GetMap();
5204 DALI_TEST_CHECK(transformMap);
5206 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5207 DALI_TEST_CHECK(offsetValue);
5208 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5210 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5211 DALI_TEST_CHECK(sizeValue);
5212 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5214 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5215 DALI_TEST_CHECK(cornerRadiusValue);
5216 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5218 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5219 DALI_TEST_CHECK(borderlineWidthValue);
5220 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5222 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5223 DALI_TEST_CHECK(borderlineColorValue);
5224 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5226 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5227 DALI_TEST_CHECK(borderlineOffsetValue);
5228 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5230 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5231 DALI_TEST_CHECK(blurRadiusValue);
5232 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5234 // Test uniform values
5235 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5236 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5237 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5238 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5239 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5244 int UtcDaliVisualGetVisualProperty03(void)
5246 ToolkitTestApplication application;
5247 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5249 static std::vector<UniformData> customUniforms =
5251 UniformData("cornerRadius", Property::Type::VECTOR4),
5252 UniformData("borderlineWidth", Property::Type::FLOAT),
5253 UniformData("borderlineColor", Property::Type::VECTOR4),
5254 UniformData("borderlineOffset", Property::Type::FLOAT),
5257 TestGraphicsController& graphics = application.GetGraphicsController();
5258 graphics.AddCustomUniforms(customUniforms);
5260 VisualFactory factory = VisualFactory::Get();
5261 Property::Map propertyMap;
5262 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5263 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5265 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5267 DummyControl dummyControl = DummyControl::New(true);
5268 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5269 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5270 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5271 application.GetScene().Add(dummyControl);
5273 // Wait for image loading
5274 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5276 application.SendNotification();
5277 application.Render();
5279 float targetOpacity = 0.5f;
5280 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5281 float targetBorderlineWidth = 10.0f;
5282 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5283 float targetBorderlineOffset = -1.5f;
5285 Animation animation = Animation::New(1.0f);
5286 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5287 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5288 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5289 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5290 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5293 application.SendNotification();
5294 application.Render();
5295 application.Render(1001u); // End of animation
5297 Property::Map resultMap;
5298 imageVisual.CreatePropertyMap(resultMap);
5300 // Test property values: they should be updated
5301 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5302 DALI_TEST_CHECK(colorValue);
5303 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5305 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5306 DALI_TEST_CHECK(cornerRadiusValue);
5307 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5309 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5310 DALI_TEST_CHECK(borderlineWidthValue);
5311 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5313 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5314 DALI_TEST_CHECK(borderlineColorValue);
5315 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5317 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5318 DALI_TEST_CHECK(borderlineOffsetValue);
5319 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5321 // Test uniform value
5322 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5323 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5324 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5325 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5330 int UtcDaliVisualGetVisualProperty04(void)
5332 ToolkitTestApplication application;
5333 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5335 static std::vector<UniformData> customUniforms =
5337 UniformData("cornerRadius", Property::Type::VECTOR4),
5340 TestGraphicsController& graphics = application.GetGraphicsController();
5341 graphics.AddCustomUniforms(customUniforms);
5343 Vector2 start(-1.f, -1.f);
5344 Vector2 end(1.f, 1.f);
5345 Property::Array stopColors;
5346 stopColors.PushBack(Color::RED);
5347 stopColors.PushBack(Color::GREEN);
5349 VisualFactory factory = VisualFactory::Get();
5350 Property::Map propertyMap;
5351 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5352 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5353 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5354 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5355 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5356 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5357 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5359 DummyControl dummyControl = DummyControl::New(true);
5360 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5361 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5362 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5363 application.GetScene().Add(dummyControl);
5365 application.SendNotification();
5366 application.Render();
5368 float targetOpacity = 0.5f;
5369 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5371 Animation animation = Animation::New(1.0f);
5372 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5373 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5376 application.SendNotification();
5377 application.Render();
5378 application.Render(1001u); // End of animation
5380 Property::Map resultMap;
5381 gradientVisual.CreatePropertyMap(resultMap);
5383 // Test property values: they should be updated
5384 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5385 DALI_TEST_CHECK(colorValue);
5386 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5388 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5389 DALI_TEST_CHECK(cornerRadiusValue);
5390 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5392 // Test uniform value
5393 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5398 int UtcDaliVisualGetVisualProperty05(void)
5400 ToolkitTestApplication application;
5401 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5403 static std::vector<UniformData> customUniforms =
5405 UniformData("cornerRadius", Property::Type::VECTOR4),
5406 UniformData("borderlineWidth", Property::Type::FLOAT),
5407 UniformData("borderlineColor", Property::Type::VECTOR4),
5408 UniformData("borderlineOffset", Property::Type::FLOAT),
5411 TestGraphicsController& graphics = application.GetGraphicsController();
5412 graphics.AddCustomUniforms(customUniforms);
5414 VisualFactory factory = VisualFactory::Get();
5415 Property::Map propertyMap;
5416 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5417 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5419 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5421 DummyControl dummyControl = DummyControl::New(true);
5422 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5423 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5424 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5425 application.GetScene().Add(dummyControl);
5427 application.SendNotification();
5428 application.Render();
5430 // Wait for loading & rasterization
5431 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5433 application.SendNotification();
5434 application.Render();
5436 float targetOpacity = 0.5f;
5437 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5438 float targetBorderlineWidth = 10.0f;
5439 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5440 float targetBorderlineOffset = -1.5f;
5442 Animation animation = Animation::New(1.0f);
5443 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5444 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5445 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5446 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5447 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5450 application.SendNotification();
5451 application.Render();
5452 application.Render(1001u); // End of animation
5454 Property::Map resultMap;
5455 svgVisual.CreatePropertyMap(resultMap);
5457 // Test property values: they should be updated
5458 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5459 DALI_TEST_CHECK(colorValue);
5460 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5462 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5463 DALI_TEST_CHECK(cornerRadiusValue);
5464 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5466 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5467 DALI_TEST_CHECK(borderlineWidthValue);
5468 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5470 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5471 DALI_TEST_CHECK(borderlineColorValue);
5472 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5474 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5475 DALI_TEST_CHECK(borderlineOffsetValue);
5476 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5478 // Currently test with multiple program doesn't work well. will fix another day
5479 // Test uniform value
5480 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5481 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5482 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5483 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5488 int UtcDaliVisualGetVisualProperty06(void)
5490 ToolkitTestApplication application;
5491 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5493 static std::vector<UniformData> customUniforms =
5495 UniformData("cornerRadius", Property::Type::VECTOR4),
5496 UniformData("borderlineWidth", Property::Type::FLOAT),
5497 UniformData("borderlineColor", Property::Type::VECTOR4),
5498 UniformData("borderlineOffset", Property::Type::FLOAT),
5501 TestGraphicsController& graphics = application.GetGraphicsController();
5502 graphics.AddCustomUniforms(customUniforms);
5504 VisualFactory factory = VisualFactory::Get();
5505 Property::Map propertyMap;
5506 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5507 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5509 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5511 DummyControl dummyControl = DummyControl::New(true);
5512 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5513 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5514 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5515 application.GetScene().Add(dummyControl);
5517 application.SendNotification();
5518 application.Render();
5520 // Wait for image loading
5521 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5523 application.SendNotification();
5524 application.Render();
5526 float targetOpacity = 0.5f;
5527 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5528 float targetBorderlineWidth = 10.0f;
5529 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5530 float targetBorderlineOffset = -1.5f;
5532 Animation animation = Animation::New(1.0f);
5533 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5534 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5535 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5536 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5537 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5540 application.SendNotification();
5541 application.Render();
5542 application.Render(1001u); // End of animation
5544 Property::Map resultMap;
5545 animatedImageVisual.CreatePropertyMap(resultMap);
5547 // Test property values: they should be updated
5548 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5549 DALI_TEST_CHECK(colorValue);
5550 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5552 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5553 DALI_TEST_CHECK(cornerRadiusValue);
5554 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5556 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5557 DALI_TEST_CHECK(borderlineWidthValue);
5558 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5560 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5561 DALI_TEST_CHECK(borderlineColorValue);
5562 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5564 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5565 DALI_TEST_CHECK(borderlineOffsetValue);
5566 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5568 // Currently test with multiple program doesn't work well. will fix another day
5569 // Test uniform value
5570 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5571 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5572 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5573 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5578 int UtcDaliVisualGetVisualProperty07(void)
5580 ToolkitTestApplication application;
5581 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5583 static std::vector<UniformData> customUniforms =
5585 UniformData("cornerRadius", Property::Type::VECTOR4),
5586 UniformData("borderlineWidth", Property::Type::FLOAT),
5587 UniformData("borderlineColor", Property::Type::VECTOR4),
5588 UniformData("borderlineOffset", Property::Type::FLOAT),
5591 TestGraphicsController& graphics = application.GetGraphicsController();
5592 graphics.AddCustomUniforms(customUniforms);
5594 VisualFactory factory = VisualFactory::Get();
5595 Property::Map propertyMap;
5596 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5597 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5599 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5601 DummyControl dummyControl = DummyControl::New(true);
5602 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5603 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5604 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5605 application.GetScene().Add(dummyControl);
5607 application.SendNotification();
5608 application.Render();
5610 // Trigger count is 2 - load & render a frame
5611 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5613 application.SendNotification();
5614 application.Render();
5616 float targetOpacity = 0.5f;
5617 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5618 float targetBorderlineWidth = 10.0f;
5619 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5620 float targetBorderlineOffset = -1.5f;
5622 Animation animation = Animation::New(1.0f);
5623 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5624 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5625 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5626 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5627 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5630 application.SendNotification();
5631 application.Render();
5632 application.Render(1001u); // End of animation
5634 Property::Map resultMap;
5635 animatedVectorVisual.CreatePropertyMap(resultMap);
5637 // Test property values: they should be updated
5638 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5639 DALI_TEST_CHECK(colorValue);
5640 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5642 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5643 DALI_TEST_CHECK(cornerRadiusValue);
5644 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5646 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5647 DALI_TEST_CHECK(borderlineWidthValue);
5648 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5650 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5651 DALI_TEST_CHECK(borderlineColorValue);
5652 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5654 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5655 DALI_TEST_CHECK(borderlineOffsetValue);
5656 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5658 // Currently test with multiple program doesn't work well. will fix another day
5659 // Test uniform value
5660 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5661 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5662 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5663 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5668 int UtcDaliVisualUpdateProperty01(void)
5670 ToolkitTestApplication application;
5671 tet_infoline("UtcDaliVisualUpdateProperty01: Test update property by DoAction. Standard case");
5673 VisualFactory factory = VisualFactory::Get();
5674 Property::Map propertyMap;
5675 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5676 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5677 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5678 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5680 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5682 DummyControl dummyControl = DummyControl::New(true);
5683 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5684 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5685 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5686 application.GetScene().Add(dummyControl);
5688 application.SendNotification();
5689 application.Render();
5691 // Wait for image loading
5692 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5694 application.SendNotification();
5695 application.Render();
5697 Property::Map originalMap;
5698 imageVisual.CreatePropertyMap(originalMap);
5700 float targetOpacity = 0.5f;
5701 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5702 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5703 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5704 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5705 float targetBorderlineWidth = 20.0f;
5706 Vector4 targetBorderlineColor = Color::RED;
5707 float targetBorderlineOffset = 1.0f;
5709 Property::Map targetPropertyMap;
5710 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5711 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5712 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5713 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5714 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5715 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5716 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5717 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5718 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5720 // Update Properties
5721 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5723 Property::Map resultMap;
5724 imageVisual.CreatePropertyMap(resultMap);
5726 // Test property values: they should be updated
5727 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5728 DALI_TEST_CHECK(colorValue);
5729 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5731 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5732 DALI_TEST_CHECK(urlValue);
5733 // NOTE : ImageVisual URL must NOT changed.
5734 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5736 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5737 DALI_TEST_CHECK(preMultipliedValue);
5738 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5740 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5741 DALI_TEST_CHECK(visualFittingModeValue);
5742 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5744 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5745 DALI_TEST_CHECK(cornerRadiusValue);
5746 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5748 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5749 DALI_TEST_CHECK(borderlineWidthValue);
5750 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5752 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5753 DALI_TEST_CHECK(borderlineColorValue);
5754 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5756 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5757 DALI_TEST_CHECK(borderlineOffsetValue);
5758 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5763 int UtcDaliVisualUpdateProperty02(void)
5765 ToolkitTestApplication application;
5766 tet_infoline("UtcDaliVisualUpdateProperty02: Test update property by DoAction. Initialize as zero, and update non-zero case");
5768 Vector4 borderlineColor = Color::BLUE;
5769 float borderlineOffset = 1.0f;
5771 VisualFactory factory = VisualFactory::Get();
5772 Property::Map propertyMap;
5773 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5774 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5775 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5776 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5777 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 0.0f;
5778 propertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5779 propertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5780 propertyMap[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
5781 propertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
5783 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5785 DummyControl dummyControl = DummyControl::New(true);
5786 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5787 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5788 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5789 application.GetScene().Add(dummyControl);
5791 application.SendNotification();
5792 application.Render();
5794 // Wait for image loading
5795 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5797 application.SendNotification();
5798 application.Render();
5800 Property::Map originalMap;
5801 imageVisual.CreatePropertyMap(originalMap);
5803 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5804 float targetBorderlineWidth = 20.0f;
5806 Property::Map targetPropertyMap;
5807 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5808 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5810 // Update Properties
5811 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5813 Property::Map resultMap;
5814 imageVisual.CreatePropertyMap(resultMap);
5816 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5817 DALI_TEST_CHECK(cornerRadiusValue);
5818 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5820 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5821 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5822 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5824 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5825 DALI_TEST_CHECK(borderlineWidthValue);
5826 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5828 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5829 DALI_TEST_CHECK(borderlineColorValue);
5830 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), borderlineColor, TEST_LOCATION);
5832 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5833 DALI_TEST_CHECK(borderlineOffsetValue);
5834 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), borderlineOffset, TEST_LOCATION);
5839 int UtcDaliVisualUpdatePropertyInvalidType(void)
5841 ToolkitTestApplication application;
5842 tet_infoline("UtcDaliVisualUpdatePropertyInvalidType: Test update property by DoAction. But some value is not invalid to update");
5844 VisualFactory factory = VisualFactory::Get();
5845 Property::Map propertyMap;
5846 propertyMap[Visual::Property::TYPE] = Visual::Type::N_PATCH;
5847 propertyMap[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
5849 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5851 DummyControl dummyControl = DummyControl::New(true);
5852 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5853 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5854 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5855 application.GetScene().Add(dummyControl);
5857 application.SendNotification();
5858 application.Render();
5860 // Wait for image loading
5861 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5863 application.SendNotification();
5864 application.Render();
5866 Property::Map originalMap;
5867 imageVisual.CreatePropertyMap(originalMap);
5869 float targetOpacity = 0.5f;
5870 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5871 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5872 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5873 Vector4 targetCornerRadius = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5874 float targetBorderlineWidth = 20.0f;
5875 Vector4 targetBorderlineColor = Color::RED;
5876 float targetBorderlineOffset = 1.0f;
5878 Property::Map targetPropertyMap;
5879 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5880 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5881 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5882 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5883 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5885 // Properties that N_PATCH visual could not used.
5886 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5887 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5888 targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5889 targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5891 // Update Properties
5892 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5894 Property::Map resultMap;
5895 imageVisual.CreatePropertyMap(resultMap);
5897 // Test property values: they should be updated
5898 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5899 DALI_TEST_CHECK(colorValue);
5900 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5902 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5903 DALI_TEST_CHECK(urlValue);
5904 // NOTE : NPatchVisual URL must NOT changed.
5905 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_NPATCH_FILE_NAME, TEST_LOCATION);
5907 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5908 DALI_TEST_CHECK(preMultipliedValue);
5909 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5911 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5912 DALI_TEST_CHECK(visualFittingModeValue);
5913 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5915 // We don't check properties value that N_PATCH visual could not used.
5921 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5923 ToolkitTestApplication application;
5924 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5926 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5928 VisualFactory factory = VisualFactory::Get();
5929 Property::Map propertyMap;
5931 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5932 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5934 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5936 DummyControl dummyControl = DummyControl::New(true);
5937 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5938 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5939 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5940 application.GetScene().Add(dummyControl);
5942 application.SendNotification();
5943 application.Render();
5945 // Wait for image loading
5946 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5948 application.SendNotification();
5949 application.Render();
5951 TestShaderCodeContainSubstrings(
5954 {"#define IS_REQUIRED_BORDERLINE", false},
5955 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5960 callStack.Enable(true);
5962 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5964 Property::Map targetPropertyMap;
5965 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5966 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5968 // Update Properties with CornerRadius
5969 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5971 Property::Map resultMap;
5972 imageVisual.CreatePropertyMap(resultMap);
5974 // Test property values: they should be updated
5975 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5976 DALI_TEST_CHECK(cornerRadiusValue);
5977 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5979 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5980 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5981 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5983 TestShaderCodeContainSubstrings(
5986 {"#define IS_REQUIRED_BORDERLINE", false},
5987 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
5991 // Send shader compile signal
5992 application.SendNotification();
5993 application.Render();
5995 callStack.Enable(false);
5997 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5999 callStack.Enable(true);
6001 float targetBorderlineWidth = 10.0f;
6002 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
6003 float targetBorderlineOffset = -0.3f;
6005 Property::Map targetPropertyMap2;
6006 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6007 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6008 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6009 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6010 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6012 // Update Properties with Borderline
6013 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6015 Property::Map resultMap2;
6016 imageVisual.CreatePropertyMap(resultMap2);
6018 // Test property values: they should be updated
6019 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6020 DALI_TEST_CHECK(cornerRadiusValue);
6021 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6023 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6024 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6025 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6027 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6028 DALI_TEST_CHECK(borderlineWidthValue);
6029 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6031 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6032 DALI_TEST_CHECK(borderlineColorValue);
6033 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6035 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6036 DALI_TEST_CHECK(borderlineOffsetValue);
6037 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6039 TestShaderCodeContainSubstrings(
6042 {"#define IS_REQUIRED_BORDERLINE", true},
6043 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6047 // Send shader compile signal
6048 application.SendNotification();
6049 application.Render();
6051 callStack.Enable(false);
6053 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6055 callStack.Enable(true);
6057 Property::Map targetPropertyMap3;
6058 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6059 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6060 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
6061 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
6062 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
6064 // Update Properties into zero
6065 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
6067 Property::Map resultMap3;
6068 imageVisual.CreatePropertyMap(resultMap3);
6070 // Test property values: they should be updated
6071 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6072 DALI_TEST_CHECK(cornerRadiusValue);
6073 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6075 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6076 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6077 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6079 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6080 DALI_TEST_CHECK(borderlineWidthValue);
6081 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
6083 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6084 DALI_TEST_CHECK(borderlineColorValue);
6085 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6087 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6088 DALI_TEST_CHECK(borderlineOffsetValue);
6089 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
6091 TestShaderCodeContainSubstrings(
6094 {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
6095 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6099 // Send shader compile signal
6100 application.SendNotification();
6101 application.Render();
6103 callStack.Enable(false);
6104 // Shader not changed
6105 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6110 int UtcDaliVisualUpdatePropertyChangeShader02(void)
6112 ToolkitTestApplication application;
6113 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
6115 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6117 VisualFactory factory = VisualFactory::Get();
6118 Property::Map propertyMap;
6120 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6121 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6123 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6125 DummyControl dummyControl = DummyControl::New(true);
6126 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6127 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6128 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6129 application.GetScene().Add(dummyControl);
6131 application.SendNotification();
6132 application.Render();
6134 // Wait for image loading
6135 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6137 application.SendNotification();
6138 application.Render();
6140 TestShaderCodeContainSubstrings(
6143 {"#define IS_REQUIRED_BORDERLINE", false},
6144 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6148 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6150 Property::Map targetPropertyMap;
6151 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6154 callStack.Enable(true);
6156 // Update Properties with CornerRadius
6157 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6159 Property::Map resultMap;
6160 imageVisual.CreatePropertyMap(resultMap);
6162 // Test property values: they should be updated
6163 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6164 DALI_TEST_CHECK(cornerRadiusValue);
6165 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6167 TestShaderCodeContainSubstrings(
6170 {"#define IS_REQUIRED_BORDERLINE", false},
6171 {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
6175 // Send shader compile signal
6176 application.SendNotification();
6177 application.Render();
6179 callStack.Enable(false);
6181 // Shader doesn't changed
6182 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6184 callStack.Enable(true);
6186 float targetBorderlineWidth = 0.0f;
6187 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
6188 float targetBorderlineOffset = -1.0f;
6190 Property::Map targetPropertyMap2;
6191 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6192 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6193 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6195 // Update Properties with Borderline
6196 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6198 Property::Map resultMap2;
6199 imageVisual.CreatePropertyMap(resultMap2);
6201 // Test property values: they should be updated
6202 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6203 DALI_TEST_CHECK(borderlineWidthValue);
6204 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6206 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6207 DALI_TEST_CHECK(borderlineColorValue);
6208 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6210 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6211 DALI_TEST_CHECK(borderlineOffsetValue);
6212 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6214 TestShaderCodeContainSubstrings(
6217 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
6218 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6222 // Send shader compile signal
6223 application.SendNotification();
6224 application.Render();
6226 callStack.Enable(false);
6228 // Shader doesn't changed
6229 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6234 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6236 ToolkitTestApplication application;
6237 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6239 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6241 VisualFactory factory = VisualFactory::Get();
6242 Property::Map propertyMap;
6244 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6245 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6247 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6249 DummyControl dummyControl = DummyControl::New(true);
6250 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6251 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6252 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6253 application.GetScene().Add(dummyControl);
6255 application.SendNotification();
6256 application.Render();
6258 application.SendNotification();
6259 application.Render();
6261 TestShaderCodeContainSubstrings(
6264 {"#define IS_REQUIRED_BLUR", false},
6265 {"#define IS_REQUIRED_BORDERLINE", false},
6266 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6270 float targetBlurRadius = 15.0f;
6271 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6273 Property::Map targetPropertyMap;
6274 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6275 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6276 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6279 callStack.Enable(true);
6281 // Update Properties with CornerRadius
6282 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6284 Property::Map resultMap;
6285 imageVisual.CreatePropertyMap(resultMap);
6287 // Test property values: they should be updated
6288 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6289 DALI_TEST_CHECK(blurRadiusValue);
6290 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6292 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6293 DALI_TEST_CHECK(cornerRadiusValue);
6294 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6296 TestShaderCodeContainSubstrings(
6299 {"#define IS_REQUIRED_BLUR", true},
6300 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6301 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6305 // Send shader compile signal
6306 application.SendNotification();
6307 application.Render();
6309 callStack.Enable(false);
6312 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6314 callStack.Enable(true);
6316 Property::Map targetPropertyMap2;
6317 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6318 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6319 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6321 // Update Properties with CornerRadius
6322 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6324 Property::Map resultMap2;
6325 imageVisual.CreatePropertyMap(resultMap2);
6327 // Test property values: they should be updated
6328 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6329 DALI_TEST_CHECK(blurRadiusValue);
6330 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6332 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6333 DALI_TEST_CHECK(cornerRadiusValue);
6334 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6336 TestShaderCodeContainSubstrings(
6339 {"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
6340 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6341 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6345 // Send shader compile signal
6346 application.SendNotification();
6347 application.Render();
6349 callStack.Enable(false);
6351 // Shader not changed
6352 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6357 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6359 ToolkitTestApplication application;
6360 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6362 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6364 VisualFactory factory = VisualFactory::Get();
6365 Property::Map propertyMap;
6367 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6368 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6369 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6371 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6373 DummyControl dummyControl = DummyControl::New(true);
6374 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6375 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6376 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6377 application.GetScene().Add(dummyControl);
6379 application.SendNotification();
6380 application.Render();
6382 // Wait for image loading
6383 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6385 application.SendNotification();
6386 application.Render();
6388 TestShaderCodeContainSubstrings(
6391 {"#define IS_REQUIRED_BORDERLINE", false},
6392 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6397 callStack.Enable(true);
6399 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6401 Animation animation = Animation::New(1.0f);
6402 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6405 application.SendNotification();
6406 application.Render();
6407 application.Render(1001u); // End of animation
6409 TestShaderCodeContainSubstrings(
6412 {"#define IS_REQUIRED_BORDERLINE", false},
6413 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6417 callStack.Enable(false);
6418 // Shader not changed
6419 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6421 callStack.Enable(true);
6423 float targetBorderlineWidth = 10.0f;
6424 Property::Map targetPropertyMap;
6425 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6427 // Update Properties with CornerRadius
6428 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6430 Property::Map resultMap;
6431 imageVisual.CreatePropertyMap(resultMap);
6433 // Test property values: they should be updated
6434 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6435 DALI_TEST_CHECK(cornerRadiusValue);
6436 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6438 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6439 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6440 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6442 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6443 DALI_TEST_CHECK(borderlineWidthValue);
6444 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6446 TestShaderCodeContainSubstrings(
6449 {"#define IS_REQUIRED_BORDERLINE", true},
6450 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6454 // Send shader compile signal
6455 application.SendNotification();
6456 application.Render();
6458 callStack.Enable(false);
6460 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));