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/color-visual-properties-devel.h>
30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
34 #include <dali/devel-api/actors/actor-devel.h>
35 #include <dali/devel-api/object/handle-devel.h>
36 #include <dali/devel-api/text-abstraction/font-client.h>
37 #include <toolkit-event-thread-callback.h>
39 #include "dummy-control.h"
42 using namespace Dali::Toolkit;
46 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
47 const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
48 const char* TEST_NPATCH_FILE_NAME = TEST_RESOURCE_DIR "/button-up.9.png";
49 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
50 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
51 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
53 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
57 Property::Map DefaultTransform()
59 Property::Map transformMap;
61 .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
62 .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
63 .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
64 .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
65 .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
66 .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
72 if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
74 for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
76 const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
78 Property::Value* valueSet = NULL;
79 if(valueGet.first.type == Property::Key::INDEX)
81 valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
85 // Get Key is a string so searching Set Map for a string key
86 valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
91 if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
93 tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
96 else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
98 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
101 else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
103 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
106 else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
108 tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
111 else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
113 Vector2 vector2Get = valueGet.second.Get<Vector2>();
114 Vector2 vector2Set = valueSet->Get<Vector2>();
115 tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
118 else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
120 Vector4 vector4Get = valueGet.second.Get<Vector4>();
121 Vector4 vector4Set = valueSet->Get<Vector4>();
122 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);
128 if(valueGet.first.type == Property::Key::INDEX)
130 tet_printf(" The key %d doesn't exist.", valueGet.first.indexKey);
134 tet_printf(" The key %s doesn't exist.", valueGet.first.stringKey.c_str());
144 void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, bool>> substringCheckList, const char* location)
146 Renderer renderer = control.GetRendererAt(0);
147 Shader shader = renderer.GetShader();
148 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
149 Property::Map* map = value.GetMap();
150 DALI_TEST_CHECK(map);
152 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
153 DALI_TEST_CHECK(fragment);
154 std::string fragmentShader;
155 DALI_TEST_CHECK(fragment->Get(fragmentShader));
156 for(const auto& checkPair : substringCheckList)
158 const auto& keyword = checkPair.first;
159 const auto& expect = checkPair.second;
160 tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
161 DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
164 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
165 std::string vertexShader;
166 DALI_TEST_CHECK(vertex->Get(vertexShader));
167 for(const auto& checkPair : substringCheckList)
169 const auto& keyword = checkPair.first;
170 const auto& expect = checkPair.second;
171 tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
172 DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
178 void dali_visual_startup(void)
180 test_return_value = TET_UNDEF;
183 void dali_visual_cleanup(void)
185 test_return_value = TET_PASS;
188 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
191 visual.CreatePropertyMap(map);
192 Property::Value* value = map.Find(mixColorIndex);
193 DALI_TEST_CHECK(value);
195 DALI_TEST_CHECK(value->Get(mixColor1));
196 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
198 value = map.Find(Visual::Property::MIX_COLOR);
199 DALI_TEST_CHECK(value);
201 DALI_TEST_CHECK(value->Get(mixColor2));
202 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
204 value = map.Find(Visual::Property::OPACITY);
205 DALI_TEST_CHECK(value);
207 DALI_TEST_CHECK(value->Get(opacity));
208 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
211 int UtcDaliVisualCopyAndAssignment(void)
213 ToolkitTestApplication application;
214 tet_infoline("UtcDaliVisualCopyAndAssignment");
216 VisualFactory factory = VisualFactory::Get();
217 Property::Map propertyMap;
218 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
219 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
220 Visual::Base visual = factory.CreateVisual(propertyMap);
222 Visual::Base visualCopy(visual);
223 DALI_TEST_CHECK(visual == visualCopy);
225 Visual::Base emptyVisual;
226 Visual::Base emptyVisualCopy(emptyVisual);
227 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
229 Visual::Base visualEquals;
230 visualEquals = visual;
231 DALI_TEST_CHECK(visual == visualEquals);
233 Visual::Base emptyVisualEquals;
234 emptyVisualEquals = emptyVisual;
235 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
239 DALI_TEST_CHECK(visual = visualCopy);
244 int UtcDaliVisualSetName01(void)
246 ToolkitTestApplication application;
247 tet_infoline("UtcDaliVisualSetName");
249 VisualFactory factory = VisualFactory::Get();
250 Property::Map propertyMap;
251 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
252 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
253 Visual::Base visual = factory.CreateVisual(propertyMap);
255 const char* visualName = "backgroundVisual";
256 visual.SetName(visualName);
258 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
263 int UtcDaliVisualSetGetDepthIndex(void)
265 ToolkitTestApplication application;
266 tet_infoline("UtcDaliVisualSetDepthIndex");
268 VisualFactory factory = VisualFactory::Get();
269 Property::Map propertyMap;
270 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
271 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
272 Visual::Base visual = factory.CreateVisual(propertyMap);
274 visual.SetDepthIndex(1);
276 DummyControl dummyControl = DummyControl::New(true);
277 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
278 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
280 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
281 application.GetScene().Add(dummyControl);
283 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
284 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
285 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
287 visual.SetDepthIndex(-1);
288 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
289 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
290 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
295 int UtcDaliVisualSize(void)
297 ToolkitTestApplication application;
298 tet_infoline("UtcDaliVisualSize");
300 VisualFactory factory = VisualFactory::Get();
301 Vector2 controlSize(20.f, 30.f);
305 Dali::Property::Map map;
306 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
307 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
309 Visual::Base colorVisual = factory.CreateVisual(map);
310 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
312 colorVisual.GetNaturalSize(naturalSize);
313 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
317 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
318 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
319 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
320 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
321 Visual::Base imageVisual = factory.CreateVisual(map);
322 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
324 imageVisual.GetNaturalSize(naturalSize);
325 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
327 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
330 float borderSize = 5.f;
332 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
333 map[BorderVisual::Property::COLOR] = Color::RED;
334 map[BorderVisual::Property::SIZE] = borderSize;
335 Visual::Base borderVisual = factory.CreateVisual(map);
336 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
337 borderVisual.GetNaturalSize(naturalSize);
338 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
340 // gradient gradientVisual
341 Property::Map propertyMap;
342 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
343 Vector2 start(-1.f, -1.f);
344 Vector2 end(1.f, 1.f);
345 propertyMap.Insert("mixColor", Color::MAGENTA);
346 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
347 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
348 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
349 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
350 Property::Array stopColors;
351 stopColors.PushBack(Color::RED);
352 stopColors.PushBack(Color::GREEN);
353 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
354 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
355 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
356 gradientVisual.GetNaturalSize(naturalSize);
357 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
359 // animated gradient visual
361 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
362 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
363 animatedGradientVisual.GetNaturalSize(naturalSize);
364 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
365 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
369 // Load some fonts to get the same metrics on different platforms.
370 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
371 fontClient.SetDpi(96u, 96u);
373 char* pathNamePtr = get_current_dir_name();
374 const std::string pathName(pathNamePtr);
377 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
379 // Create a TextVisual with a font size of 12 first
381 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
382 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
383 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
384 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
386 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
387 Vector2 smallTextVisualNaturalSize;
388 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
390 // Then create a TextVisual with a font size of 20
391 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
392 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
393 Vector2 largeTextVisualNaturalSize;
394 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
396 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
397 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
398 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
400 // The height returned for a particular width should also be greater for the large text visual
401 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
403 //AnimatedImageVisual
404 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
405 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
406 animatedImageVisual.GetNaturalSize(naturalSize);
407 // TEST_GIF_FILE: anim.gif
408 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
409 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
414 int UtcDaliVisualSetOnOffScene(void)
416 ToolkitTestApplication application;
417 tet_infoline("UtcDaliVisualSetOnOffScene");
419 VisualFactory factory = VisualFactory::Get();
420 Property::Map propertyMap;
421 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
422 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
423 Visual::Base visual = factory.CreateVisual(propertyMap);
425 DummyControl actor = DummyControl::New(true);
426 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
427 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
429 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
431 application.SendNotification();
432 application.Render(0);
433 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
435 application.GetScene().Add(actor);
437 application.SendNotification();
438 application.Render(0);
439 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
441 application.GetScene().Remove(actor);
443 application.SendNotification();
444 application.Render(0);
445 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
450 int UtcDaliVisualSetOnOffScene2(void)
452 ToolkitTestApplication application;
453 tet_infoline("UtcDaliVisualSetOnOffScene2");
455 VisualFactory factory = VisualFactory::Get();
456 Property::Map propertyMap;
457 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
458 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
459 Visual::Base visual = factory.CreateVisual(propertyMap);
461 DummyControl actor = DummyControl::New(true);
462 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
463 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
465 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
467 application.SendNotification();
468 application.Render(0);
469 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
472 application.GetScene().Add(actor);
474 application.SendNotification();
475 application.Render(0);
477 // Wait for loading & rasterization
478 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
480 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
481 Renderer renderer = actor.GetRendererAt(0);
482 auto textures = renderer.GetTextures();
483 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
485 application.GetScene().Remove(actor);
487 application.SendNotification();
488 application.Render(0);
489 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
492 application.GetScene().Add(actor);
494 application.SendNotification();
495 application.Render(0);
496 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
497 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
498 renderer = actor.GetRendererAt(0);
499 textures = renderer.GetTextures();
500 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
502 application.GetScene().Remove(actor);
504 application.SendNotification();
505 application.Render(0);
506 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
511 int UtcDaliVisualGetPropertyMap1(void)
513 ToolkitTestApplication application;
514 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
516 VisualFactory factory = VisualFactory::Get();
517 Property::Map propertyMap;
518 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
519 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
520 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
521 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
522 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
523 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
524 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
525 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
526 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
528 Property::Map resultMap;
529 colorVisual.CreatePropertyMap(resultMap);
531 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
532 DALI_TEST_CHECK(typeValue);
533 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
535 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
536 DALI_TEST_CHECK(colorValue);
537 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
539 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
540 DALI_TEST_CHECK(cornerRadiusValue);
541 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
543 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
544 DALI_TEST_CHECK(cornerRadiusPolicyValue);
545 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
547 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
548 DALI_TEST_CHECK(borderlineWidthValue);
549 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
551 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
552 DALI_TEST_CHECK(borderlineColorValue);
553 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
555 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
556 DALI_TEST_CHECK(borderlineOffsetValue);
557 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
559 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
560 DALI_TEST_CHECK(blurRadiusValue);
561 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
563 // change the blend color
564 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
565 colorVisual = factory.CreateVisual(propertyMap);
566 colorVisual.CreatePropertyMap(resultMap);
568 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
569 DALI_TEST_CHECK(colorValue);
570 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
573 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
575 colorVisual = factory.CreateVisual(propertyMap);
576 colorVisual.CreatePropertyMap(resultMap);
578 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
579 DALI_TEST_CHECK(blurRadiusValue);
580 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
585 int UtcDaliVisualGetPropertyMap2(void)
587 ToolkitTestApplication application;
588 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
590 VisualFactory factory = VisualFactory::Get();
591 Property::Map propertyMap;
592 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
593 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
594 propertyMap.Insert("borderColor", Color::BLUE);
595 propertyMap.Insert("borderSize", 5.f);
596 propertyMap.Insert("antiAliasing", true);
597 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
599 Property::Map resultMap;
600 borderVisual.CreatePropertyMap(resultMap);
602 // check the property values from the returned map from visual
603 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
604 DALI_TEST_CHECK(typeValue);
605 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
607 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
608 DALI_TEST_CHECK(colorValue);
609 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
611 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
612 DALI_TEST_CHECK(sizeValue);
613 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
615 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
616 DALI_TEST_CHECK(AAValue);
617 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
619 Property::Map propertyMap1;
620 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
621 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
622 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
623 borderVisual = factory.CreateVisual(propertyMap1);
624 borderVisual.CreatePropertyMap(resultMap);
626 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
627 DALI_TEST_CHECK(typeValue);
628 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
630 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
631 DALI_TEST_CHECK(colorValue);
632 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
634 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
635 DALI_TEST_CHECK(sizeValue);
636 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
641 int UtcDaliVisualGetPropertyMap2N(void)
643 ToolkitTestApplication application;
644 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
646 VisualFactory factory = VisualFactory::Get();
647 Property::Map propertyMap;
648 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
649 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
651 tet_infoline("Test that the visual is created, with a default renderer");
652 DALI_TEST_CHECK(borderVisual);
654 DummyControl dummyControl = DummyControl::New(true);
655 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
656 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
657 application.GetScene().Add(dummyControl);
659 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
664 int UtcDaliVisualGetPropertyMap3(void)
666 ToolkitTestApplication application;
667 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
669 VisualFactory factory = VisualFactory::Get();
670 DALI_TEST_CHECK(factory);
672 Property::Map propertyMap;
673 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
675 Vector2 start(-1.f, -1.f);
676 Vector2 end(1.f, 1.f);
677 propertyMap.Insert("startPosition", start);
678 propertyMap.Insert("endPosition", end);
679 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
681 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
683 Property::Array stopColors;
684 stopColors.PushBack(Color::RED);
685 stopColors.PushBack(Color::GREEN);
686 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
688 float borderlineWidth = 4.0f;
689 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
690 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
691 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
693 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
695 Property::Map resultMap;
696 gradientVisual.CreatePropertyMap(resultMap);
698 // check the property values from the returned map from visual
699 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
700 DALI_TEST_CHECK(value);
701 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
703 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
704 DALI_TEST_CHECK(value);
705 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
707 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
708 DALI_TEST_CHECK(value);
709 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
711 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
712 DALI_TEST_CHECK(value);
713 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
715 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
716 DALI_TEST_CHECK(value);
717 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
719 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
720 DALI_TEST_CHECK(value);
721 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
723 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
724 DALI_TEST_CHECK(value);
725 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
727 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
728 DALI_TEST_CHECK(value);
729 Property::Array* offsetArray = value->GetArray();
730 DALI_TEST_CHECK(offsetArray->Count() == 2);
731 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
732 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
734 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
735 DALI_TEST_CHECK(value);
736 Property::Array* colorArray = value->GetArray();
737 DALI_TEST_CHECK(colorArray->Count() == 2);
738 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
739 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
744 int UtcDaliVisualGetPropertyMap4(void)
746 ToolkitTestApplication application;
747 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
749 VisualFactory factory = VisualFactory::Get();
750 DALI_TEST_CHECK(factory);
752 Property::Map propertyMap;
753 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
755 Vector2 center(100.f, 100.f);
756 float radius = 100.f;
757 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
758 propertyMap.Insert(GradientVisual::Property::CENTER, center);
759 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
760 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
762 Property::Array stopColors;
763 stopColors.PushBack(Color::RED);
764 stopColors.PushBack(Color::BLACK);
765 stopColors.PushBack(Color::GREEN);
766 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
768 float borderlineWidth = 8.0f;
769 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
770 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
771 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
773 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
774 DALI_TEST_CHECK(gradientVisual);
776 Property::Map resultMap;
777 gradientVisual.CreatePropertyMap(resultMap);
779 // check the property values from the returned map from visual
780 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
781 DALI_TEST_CHECK(value);
782 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
784 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
785 DALI_TEST_CHECK(value);
786 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
788 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
789 DALI_TEST_CHECK(value);
790 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
792 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
793 DALI_TEST_CHECK(value);
794 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
796 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
797 DALI_TEST_CHECK(value);
798 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
800 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
801 DALI_TEST_CHECK(value);
802 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
804 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
805 DALI_TEST_CHECK(value);
806 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
808 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
809 DALI_TEST_CHECK(value);
810 Property::Array* offsetArray = value->GetArray();
811 DALI_TEST_CHECK(offsetArray->Count() == 3);
812 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
813 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
814 // any stop value will be clamped to [0.0, 1.0];
815 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
817 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
818 DALI_TEST_CHECK(value);
819 Property::Array* colorArray = value->GetArray();
820 DALI_TEST_CHECK(colorArray->Count() == 3);
821 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
822 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
823 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
828 int UtcDaliVisualGetPropertyMap5(void)
830 ToolkitTestApplication application;
831 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
833 VisualFactory factory = VisualFactory::Get();
834 Property::Map propertyMap;
835 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
836 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
837 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
838 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
839 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
840 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
841 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
842 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
843 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
844 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
845 propertyMap.Insert("synchronousLoading", true);
847 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
848 DALI_TEST_CHECK(imageVisual);
850 Property::Map resultMap;
851 imageVisual.CreatePropertyMap(resultMap);
853 // check the property values from the returned map from visual
854 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
855 DALI_TEST_CHECK(value);
856 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
858 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
859 DALI_TEST_CHECK(value);
860 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
862 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
863 DALI_TEST_CHECK(value);
864 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
866 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
867 DALI_TEST_CHECK(value);
868 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
870 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
871 DALI_TEST_CHECK(value);
872 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
874 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
875 DALI_TEST_CHECK(value);
876 DALI_TEST_CHECK(value->Get<int>() == 20);
878 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
879 DALI_TEST_CHECK(value);
880 DALI_TEST_CHECK(value->Get<int>() == 30);
882 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
883 DALI_TEST_CHECK(value);
884 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
886 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
887 DALI_TEST_CHECK(value);
888 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
890 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
891 DALI_TEST_CHECK(value);
892 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
894 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
895 DALI_TEST_CHECK(value);
896 DALI_TEST_CHECK(value->Get<bool>() == true);
901 int UtcDaliVisualGetPropertyMap6(void)
903 ToolkitTestApplication application;
904 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
906 Rect<int> border(1, 1, 1, 1);
908 VisualFactory factory = VisualFactory::Get();
909 Property::Map propertyMap;
910 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
911 propertyMap.Insert("mixColor", Color::MAGENTA);
912 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
913 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
914 propertyMap.Insert(ImageVisual::Property::BORDER, border);
915 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
916 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
917 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
919 Property::Map resultMap;
920 nPatchVisual.CreatePropertyMap(resultMap);
922 // check the property values from the returned map from visual
923 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
924 DALI_TEST_CHECK(value);
925 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
927 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
928 DALI_TEST_CHECK(value);
929 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
931 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
932 DALI_TEST_CHECK(value);
933 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
935 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
936 DALI_TEST_CHECK(value);
937 DALI_TEST_CHECK(value->Get<bool>());
939 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
940 DALI_TEST_CHECK(value);
941 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
943 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
944 DALI_TEST_CHECK(value);
945 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
947 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
948 DALI_TEST_CHECK(value);
949 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
951 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
953 Property::Map propertyMap1;
954 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
955 propertyMap1.Insert("mixColor", Color::MAGENTA);
956 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
957 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
958 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
959 nPatchVisual = factory.CreateVisual(propertyMap1);
961 nPatchVisual.CreatePropertyMap(resultMap);
963 // check the property values from the returned map from visual
964 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
965 DALI_TEST_CHECK(value);
966 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
968 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
969 DALI_TEST_CHECK(value);
970 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
972 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
973 DALI_TEST_CHECK(value);
974 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
976 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
977 DALI_TEST_CHECK(value);
978 DALI_TEST_CHECK(value->Get<bool>());
980 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
981 DALI_TEST_CHECK(value);
982 DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
987 int UtcDaliVisualGetPropertyMap7(void)
989 ToolkitTestApplication application;
990 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
992 // request SvgVisual with a property map
993 VisualFactory factory = VisualFactory::Get();
994 Property::Map propertyMap;
995 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
996 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
997 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
998 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
999 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
1001 Property::Map resultMap;
1002 svgVisual.CreatePropertyMap(resultMap);
1003 // check the property values from the returned map from a visual
1004 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1005 DALI_TEST_CHECK(value);
1006 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1008 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1009 DALI_TEST_CHECK(value);
1010 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1012 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1013 DALI_TEST_CHECK(value);
1014 DALI_TEST_CHECK(value->Get<bool>() == false);
1016 // request SvgVisual with a property map 2
1017 propertyMap.Clear();
1018 propertyMap["visualType"] = Visual::SVG;
1019 propertyMap["mixColor"] = Color::WHITE;
1020 propertyMap["url"] = TEST_SVG_FILE_NAME;
1021 propertyMap["atlasing"] = true;
1022 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1025 svgVisual1.CreatePropertyMap(resultMap);
1026 // check the property values from the returned map from a visual
1027 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1028 DALI_TEST_CHECK(value);
1029 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1031 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1032 DALI_TEST_CHECK(value);
1033 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1035 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1036 DALI_TEST_CHECK(value);
1037 DALI_TEST_CHECK(value->Get<bool>() == true);
1039 // request SvgVisual with an URL
1040 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1042 svgVisual2.CreatePropertyMap(resultMap);
1043 // check the property values from the returned map from a visual
1044 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1045 DALI_TEST_CHECK(value);
1046 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1048 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1049 DALI_TEST_CHECK(value);
1050 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1056 int UtcDaliVisualGetPropertyMap8(void)
1058 ToolkitTestApplication application;
1059 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1061 //Request MeshVisual using a property map.
1062 VisualFactory factory = VisualFactory::Get();
1063 Property::Map propertyMap;
1064 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1065 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1066 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1067 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1068 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1069 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1070 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1071 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1073 Property::Map resultMap;
1074 meshVisual.CreatePropertyMap(resultMap);
1075 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1077 //Check values in the result map are identical to the initial map's values.
1078 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1079 DALI_TEST_CHECK(value);
1080 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1082 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1083 DALI_TEST_CHECK(value);
1084 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1086 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1087 DALI_TEST_CHECK(value);
1088 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1090 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1091 DALI_TEST_CHECK(value);
1092 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1094 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1095 DALI_TEST_CHECK(value);
1096 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1098 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1099 DALI_TEST_CHECK(value);
1100 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1105 //Primitive shape visual
1106 int UtcDaliVisualGetPropertyMap9(void)
1108 ToolkitTestApplication application;
1109 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1111 static std::vector<UniformData> customUniforms =
1113 UniformData("mixColor", Property::Type::VECTOR3),
1116 TestGraphicsController& graphics = application.GetGraphicsController();
1117 graphics.AddCustomUniforms(customUniforms);
1119 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1120 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1122 //Request PrimitiveVisual using a property map.
1123 VisualFactory factory = VisualFactory::Get();
1124 Property::Map propertyMap;
1125 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1126 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1127 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1128 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1129 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1130 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1131 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1132 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1133 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1134 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1135 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1136 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1137 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1138 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1140 Property::Map resultMap;
1141 primitiveVisual.CreatePropertyMap(resultMap);
1143 //Check values in the result map are identical to the initial map's values.
1144 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1145 DALI_TEST_CHECK(value);
1146 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1148 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1149 DALI_TEST_CHECK(value);
1150 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1152 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1153 DALI_TEST_CHECK(value);
1154 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1155 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1157 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1158 DALI_TEST_CHECK(value);
1159 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1161 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1162 DALI_TEST_CHECK(value);
1163 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1165 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1166 DALI_TEST_CHECK(value);
1167 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1169 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1170 DALI_TEST_CHECK(value);
1171 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1173 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1174 DALI_TEST_CHECK(value);
1175 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1177 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1178 DALI_TEST_CHECK(value);
1179 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1181 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1182 DALI_TEST_CHECK(value);
1183 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1185 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1186 DALI_TEST_CHECK(value);
1187 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1189 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1190 DALI_TEST_CHECK(value);
1191 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1193 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1194 DALI_TEST_CHECK(value);
1195 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1197 DummyControl actor = DummyControl::New(true);
1198 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1199 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1200 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1201 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1202 application.GetScene().Add(actor);
1204 Animation animation = Animation::New(1.0f);
1205 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1207 application.SendNotification();
1208 application.Render(0);
1209 application.Render(1000);
1210 application.SendNotification();
1212 auto& gl = application.GetGlAbstraction();
1213 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1215 tet_infoline("Check property map after animation");
1217 primitiveVisual.CreatePropertyMap(resultMap);
1218 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1219 DALI_TEST_CHECK(value);
1220 color = value->Get<Vector4>();
1221 // Ignore alpha part
1222 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1228 int UtcDaliVisualGetPropertyMap10(void)
1230 ToolkitTestApplication application;
1231 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1233 //Request PrimitiveVisual using a property map.
1234 VisualFactory factory = VisualFactory::Get();
1236 Property::Map propertyMap;
1237 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1238 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1239 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1240 propertyMap.Insert("enableMarkup", false);
1241 propertyMap.Insert("text", "Hello world");
1242 propertyMap.Insert("fontFamily", "TizenSans");
1244 Property::Map fontStyleMapSet;
1245 fontStyleMapSet.Insert("weight", "bold");
1246 propertyMap.Insert("fontStyle", fontStyleMapSet);
1248 propertyMap.Insert("pointSize", 12.f);
1249 propertyMap.Insert("multiLine", true);
1250 propertyMap.Insert("horizontalAlignment", "CENTER");
1251 propertyMap.Insert("verticalAlignment", "CENTER");
1252 propertyMap.Insert("textColor", Color::RED);
1254 Property::Map shadowMapSet;
1255 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1257 Property::Map underlineMapSet;
1258 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));
1260 Property::Map outlineMapSet;
1261 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1263 Property::Map backgroundMapSet;
1264 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1266 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1268 Property::Map resultMap;
1269 textVisual.CreatePropertyMap(resultMap);
1271 //Check values in the result map are identical to the initial map's values.
1272 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1273 DALI_TEST_CHECK(value);
1274 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1276 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1277 DALI_TEST_CHECK(value);
1278 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1280 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1281 DALI_TEST_CHECK(value);
1282 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1284 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1285 DALI_TEST_CHECK(value);
1286 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1288 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1289 DALI_TEST_CHECK(value);
1291 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1292 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1293 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1295 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1296 DALI_TEST_CHECK(value);
1297 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1299 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1300 DALI_TEST_CHECK(value);
1301 DALI_TEST_CHECK(value->Get<bool>());
1303 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1304 DALI_TEST_CHECK(value);
1305 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1307 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1308 DALI_TEST_CHECK(value);
1309 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1311 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1312 DALI_TEST_CHECK(value);
1313 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1315 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1316 DALI_TEST_CHECK(value);
1317 DALI_TEST_CHECK(!value->Get<bool>());
1319 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1320 DALI_TEST_CHECK(value);
1322 Property::Map shadowMapGet = value->Get<Property::Map>();
1323 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1324 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1326 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1327 DALI_TEST_CHECK(value);
1329 Property::Map underlineMapGet = value->Get<Property::Map>();
1330 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1331 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1333 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1334 DALI_TEST_CHECK(value);
1336 Property::Map outlineMapGet = value->Get<Property::Map>();
1337 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1338 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1340 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1341 DALI_TEST_CHECK(value);
1343 Property::Map backgroundMapGet = value->Get<Property::Map>();
1344 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1345 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1350 int UtcDaliVisualGetPropertyMap11(void)
1352 ToolkitTestApplication application;
1353 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1355 VisualFactory factory = VisualFactory::Get();
1356 DALI_TEST_CHECK(factory);
1358 Property::Map propertyMap;
1359 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1361 Vector2 start(-0.5f, 0.5f);
1362 Vector2 end(0.5f, -0.0f);
1363 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1364 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1365 Vector2 rotate_center(0.0f, 0.4f);
1366 float rotate_amount = 1.57f;
1367 float offset = 100.f;
1369 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1370 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1371 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1373 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1374 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1375 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1376 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1377 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1378 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1379 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1381 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1382 DALI_TEST_CHECK(animatedGradientVisual);
1384 Property::Map resultMap;
1385 animatedGradientVisual.CreatePropertyMap(resultMap);
1387 // check the property values from the returned map from visual
1388 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1389 DALI_TEST_CHECK(value);
1390 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1392 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1393 DALI_TEST_CHECK(value);
1394 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1396 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1397 DALI_TEST_CHECK(value);
1398 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1400 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1401 DALI_TEST_CHECK(value);
1402 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1404 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1405 DALI_TEST_CHECK(value);
1406 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1408 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1409 DALI_TEST_CHECK(value);
1410 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1412 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1413 DALI_TEST_CHECK(value);
1414 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1416 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1417 DALI_TEST_CHECK(value);
1418 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1420 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1421 DALI_TEST_CHECK(value);
1422 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1424 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1425 DALI_TEST_CHECK(value);
1426 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1428 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1429 DALI_TEST_CHECK(value);
1430 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1435 int UtcDaliVisualGetPropertyMap12(void)
1437 ToolkitTestApplication application;
1438 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1440 // Case 1 : Set values by index
1442 tet_printf(" - Set Values by Index\n");
1443 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1444 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1445 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1447 tet_printf("test with delay [%f]\n", _delay);
1448 VisualFactory factory = VisualFactory::Get();
1449 DALI_TEST_CHECK(factory);
1451 Property::Map propertyMap;
1452 Property::Map animationMap;
1453 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1455 float duration = 1.1f;
1456 float delay = _delay;
1457 float repeat_delay = 0.4f;
1459 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1461 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1462 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1464 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1465 animationMap.Clear();
1466 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1467 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1468 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1469 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1470 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1471 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1472 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1473 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1474 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1476 return animationMap;
1479 Vector2 start1(-0.5f, 0.5f);
1480 Vector2 end1(0.5f, -0.5f);
1481 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1482 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1483 Vector2 rotate_center1(0.0f, 0.4f);
1484 float rotate_amount1 = 0.0f;
1485 float offset1 = 0.f;
1487 Vector2 start2(-0.5f, -0.5f);
1488 Vector2 end2(0.5f, 0.5f);
1489 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1490 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1491 Vector2 rotate_center2(0.0f, -0.4f);
1492 float rotate_amount2 = 6.2832f;
1493 float offset2 = 2.f;
1495 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1496 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1497 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1499 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1500 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1501 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1502 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1503 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1504 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1505 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1507 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1508 DALI_TEST_CHECK(animatedGradientVisual);
1510 Property::Map resultMap;
1511 animatedGradientVisual.CreatePropertyMap(resultMap);
1513 // check the property values from the returned map from visual
1514 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1515 DALI_TEST_CHECK(value);
1516 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1518 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1519 DALI_TEST_CHECK(value);
1520 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1522 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1523 DALI_TEST_CHECK(value);
1524 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1526 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1527 DALI_TEST_CHECK(value);
1528 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1530 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 {
1531 tet_printf("Check value at %d\n", line_num);
1532 value = resultMap.Find(index, Property::MAP);
1533 DALI_TEST_CHECK(value);
1534 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1535 Property::Map* temp_map = value->GetMap();
1536 DALI_TEST_CHECK(temp_map);
1538 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1539 Property::Value* res = temp_map->Find(index);
1540 DALI_TEST_CHECK(res);
1544 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1545 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1546 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1547 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1548 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1549 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1550 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1551 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1552 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1555 // check the animation map data is good
1556 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1557 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1558 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1559 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1560 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1561 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1562 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1566 // Case 2 : Set values by string
1568 tet_printf(" - Set Values by String\n");
1569 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1570 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1571 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1573 tet_printf("test with delay [%f]\n", _delay);
1574 VisualFactory factory = VisualFactory::Get();
1575 DALI_TEST_CHECK(factory);
1577 Property::Map propertyMap;
1578 Property::Map animationMap;
1579 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1581 float duration = 1.1f;
1582 float delay = _delay;
1583 float repeat_delay = 0.4f;
1585 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1587 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1588 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1590 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1591 animationMap.Clear();
1592 animationMap.Insert("startValue", start);
1593 animationMap.Insert("targetValue", target);
1594 animationMap.Insert("directionType", "BACKWARD");
1595 animationMap.Insert("duration", duration);
1596 animationMap.Insert("delay", delay);
1597 animationMap.Insert("repeat", loop_count);
1598 animationMap.Insert("repeatDelay", repeat_delay);
1599 animationMap.Insert("motionType", "MIRROR");
1600 animationMap.Insert("easingType", "IN_OUT");
1602 return animationMap;
1605 Vector2 start1(-0.5f, 0.5f);
1606 Vector2 end1(0.5f, -0.5f);
1607 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1608 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1609 Vector2 rotate_center1(0.0f, 0.4f);
1610 float rotate_amount1 = 0.0f;
1611 float offset1 = 0.f;
1613 Vector2 start2(-0.5f, -0.5f);
1614 Vector2 end2(0.5f, 0.5f);
1615 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1616 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1617 Vector2 rotate_center2(0.0f, -0.4f);
1618 float rotate_amount2 = 6.2832f;
1619 float offset2 = 2.f;
1621 // For test mix the type string/index key and string/index value works well.
1622 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1623 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1624 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1626 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1627 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1628 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1629 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1630 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1631 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1632 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1634 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1635 DALI_TEST_CHECK(animatedGradientVisual);
1637 Property::Map resultMap;
1638 animatedGradientVisual.CreatePropertyMap(resultMap);
1640 // check the property values from the returned map from visual
1641 // Note : resultMap from CreatePropertyMap only contain indexKey
1642 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1643 DALI_TEST_CHECK(value);
1644 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1646 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1647 DALI_TEST_CHECK(value);
1648 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1650 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1651 DALI_TEST_CHECK(value);
1652 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1654 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1655 DALI_TEST_CHECK(value);
1656 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1658 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 {
1659 tet_printf("Check value at %d\n", line_num);
1660 value = resultMap.Find(index, Property::MAP);
1661 DALI_TEST_CHECK(value);
1662 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1663 Property::Map* temp_map = value->GetMap();
1664 DALI_TEST_CHECK(temp_map);
1666 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1667 Property::Value* res = temp_map->Find(index);
1668 DALI_TEST_CHECK(res);
1672 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1673 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1674 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1675 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1676 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1677 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1678 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1679 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1680 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1683 // check the animation map data is good
1684 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1685 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1686 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1687 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1688 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1689 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1690 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1696 int UtcDaliVisualGetPropertyMap13(void)
1698 ToolkitTestApplication application;
1699 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1701 for(int _direction = 0; _direction <= 1; ++_direction)
1703 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1705 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1706 VisualFactory factory = VisualFactory::Get();
1707 DALI_TEST_CHECK(factory);
1709 Property::Map propertyMap;
1710 Property::Map animationMap;
1711 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1713 float duration = 1.0f;
1714 float delay = _delay;
1715 float repeat_delay = 0.5f;
1717 int direction = _direction;
1718 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1719 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1720 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1722 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1723 animationMap.Clear();
1724 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1725 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1727 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1729 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1730 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1731 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1732 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1733 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1734 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1735 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1736 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1738 return animationMap;
1741 Vector2 start1(-0.5f, 0.5f);
1742 Vector2 end1(0.5f, -0.5f);
1743 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1744 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1745 Vector2 rotate_center1(1.0f, 0.4f);
1746 float rotate_amount1 = 2.0f;
1747 float offset1 = 1.f;
1749 Vector2 start2(-0.5f, -0.5f);
1750 Vector2 end2(0.5f, 0.5f);
1751 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1752 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1753 Vector2 rotate_center2(1.0f, -0.4f);
1754 float rotate_amount2 = 1.0f;
1755 float offset2 = 3.f;
1757 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1758 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1759 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1761 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1762 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1763 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1764 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1765 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1766 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1767 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1769 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1770 DALI_TEST_CHECK(animatedGradientVisual);
1772 Property::Map resultMap;
1773 animatedGradientVisual.CreatePropertyMap(resultMap);
1775 // check the property values from the returned map from visual
1776 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1777 DALI_TEST_CHECK(value);
1778 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1780 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1781 DALI_TEST_CHECK(value);
1782 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1784 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1785 DALI_TEST_CHECK(value);
1786 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1788 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1789 DALI_TEST_CHECK(value);
1790 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1792 // If loop_count = 0, Animation doesn't created.
1793 // Optimized resultMap only have one value, which is target value
1794 // Note: target value will be changed by direction option.
1795 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1796 DALI_TEST_CHECK(value);
1797 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1799 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1800 DALI_TEST_CHECK(value);
1801 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1803 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1804 DALI_TEST_CHECK(value);
1805 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1807 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1808 DALI_TEST_CHECK(value);
1809 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1811 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1812 DALI_TEST_CHECK(value);
1813 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1815 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1816 DALI_TEST_CHECK(value);
1817 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1819 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1820 DALI_TEST_CHECK(value);
1821 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1828 int UtcDaliVisualAnimateBorderVisual01(void)
1830 ToolkitTestApplication application;
1831 tet_infoline("UtcDaliAnimateBorderVisual Color");
1833 static std::vector<UniformData> customUniforms =
1835 UniformData("borderColor", Property::Type::VECTOR4),
1836 UniformData("mixColor", Property::Type::VECTOR3),
1839 TestGraphicsController& graphics = application.GetGraphicsController();
1840 graphics.AddCustomUniforms(customUniforms);
1842 VisualFactory factory = VisualFactory::Get();
1843 Property::Map propertyMap;
1844 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1845 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1846 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1847 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1848 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1851 map["target"] = "testVisual";
1852 map["property"] = "mixColor";
1853 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1854 map["animator"] = Property::Map()
1855 .Add("alphaFunction", "LINEAR")
1856 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1858 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1860 DummyControl actor = DummyControl::New(true);
1861 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1862 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1863 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1864 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1865 application.GetScene().Add(actor);
1867 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1869 Renderer renderer = actor.GetRendererAt(0);
1870 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1871 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1873 Animation animation = dummyImpl.CreateTransition(transition);
1875 // Animate the mix color through the transition, and the border color through
1876 // programmatic method.
1877 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1880 application.SendNotification();
1881 application.Render(0);
1882 application.Render(2000u); // halfway point between blue and white
1884 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1885 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1886 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1887 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1889 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1890 testColor = Vector4(1, 1, 1, 0.45f);
1891 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1892 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1895 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1896 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1898 application.Render(2000u);
1900 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1901 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1902 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1904 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1905 testColor = Vector4(1, 1, 1, 0.1);
1906 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1907 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1909 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1910 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1915 int UtcDaliVisualAnimateBorderVisual02(void)
1917 ToolkitTestApplication application;
1918 tet_infoline("UtcDaliAnimateBorderVisual Size");
1920 static std::vector<UniformData> customUniforms =
1922 UniformData("borderSize", Property::Type::FLOAT),
1925 TestGraphicsController& graphics = application.GetGraphicsController();
1926 graphics.AddCustomUniforms(customUniforms);
1928 VisualFactory factory = VisualFactory::Get();
1929 Property::Map propertyMap;
1930 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1931 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1932 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1933 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1935 DummyControl actor = DummyControl::New(true);
1936 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1937 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1938 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1939 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1940 application.GetScene().Add(actor);
1942 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1944 Renderer renderer = actor.GetRendererAt(0);
1945 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1947 Animation animation = Animation::New(4.0f);
1948 animation.AnimateTo(Property(renderer, index), 9.0f);
1951 application.SendNotification();
1952 application.Render(0);
1953 application.Render(2000u); // halfway point
1955 float size = renderer.GetCurrentProperty<float>(index);
1956 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1957 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1959 application.Render(2000u); // halfway point between blue and white
1961 size = renderer.GetCurrentProperty<float>(index);
1962 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1963 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1968 int UtcDaliVisualAnimateColorVisual(void)
1970 ToolkitTestApplication application;
1971 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1973 static std::vector<UniformData> customUniforms =
1975 UniformData("mixColor", Property::Type::VECTOR3),
1978 TestGraphicsController& graphics = application.GetGraphicsController();
1979 graphics.AddCustomUniforms(customUniforms);
1981 VisualFactory factory = VisualFactory::Get();
1982 Property::Map propertyMap;
1983 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1984 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1985 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1987 DummyControl actor = DummyControl::New(true);
1988 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1989 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1990 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1991 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1992 application.GetScene().Add(actor);
1994 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1996 Renderer renderer = actor.GetRendererAt(0);
1997 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1999 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
2000 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2002 Animation animation = Animation::New(4.0f);
2003 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2006 application.SendNotification();
2007 application.Render(0);
2008 application.Render(2000u); // halfway point
2010 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2011 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2012 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2014 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2016 application.Render(2000u); // halfway point between blue and white
2018 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2019 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2021 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2023 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2024 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2029 int UtcDaliVisualAnimatePrimitiveVisual(void)
2031 ToolkitTestApplication application;
2032 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2034 static std::vector<UniformData> customUniforms =
2036 UniformData("mixColor", Property::Type::VECTOR3),
2039 TestGraphicsController& graphics = application.GetGraphicsController();
2040 graphics.AddCustomUniforms(customUniforms);
2043 VisualFactory factory = VisualFactory::Get();
2044 Property::Map propertyMap;
2045 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2046 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2047 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2048 Visual::Base visual = factory.CreateVisual(propertyMap);
2050 DummyControl actor = DummyControl::New(true);
2051 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2052 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2053 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2054 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2055 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2056 application.GetScene().Add(actor);
2058 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2060 Renderer renderer = actor.GetRendererAt(0);
2062 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2063 const Vector4 TARGET_MIX_COLOR(Color::RED);
2066 map["target"] = "testVisual";
2067 map["property"] = "mixColor";
2068 map["initialValue"] = INITIAL_MIX_COLOR;
2069 map["targetValue"] = TARGET_MIX_COLOR;
2070 map["animator"] = Property::Map()
2071 .Add("alphaFunction", "LINEAR")
2072 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2074 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2076 Animation animation = dummyImpl.CreateTransition(transition);
2077 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2080 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2081 glAbstraction.EnableEnableDisableCallTrace(true);
2082 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2083 std::ostringstream blendStr;
2084 blendStr << std::hex << GL_BLEND;
2086 application.SendNotification();
2087 application.Render(0);
2088 application.Render(2000u); // halfway point
2089 application.SendNotification();
2091 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2092 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2093 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2095 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2097 glEnableStack.Reset();
2099 application.Render(2001u); // go past end
2100 application.SendNotification(); // Trigger signals
2102 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2103 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2104 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2106 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2114 int UtcDaliVisualAnimatedGradientVisual01(void)
2116 ToolkitTestApplication application;
2117 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2119 static std::vector<UniformData> customUniforms =
2121 UniformData("start_point", Property::Type::VECTOR2),
2122 UniformData("end_point", Property::Type::VECTOR2),
2123 UniformData("start_color", Property::Type::VECTOR4),
2124 UniformData("end_color", Property::Type::VECTOR4),
2125 UniformData("rotate_center", Property::Type::VECTOR2),
2126 UniformData("rotate_angle", Property::Type::FLOAT),
2127 UniformData("gradient_offset", Property::Type::FLOAT),
2130 TestGraphicsController& graphics = application.GetGraphicsController();
2131 graphics.AddCustomUniforms(customUniforms);
2134 VisualFactory factory = VisualFactory::Get();
2135 Property::Map propertyMap;
2136 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2137 Visual::Base visual = factory.CreateVisual(propertyMap);
2139 DummyControl actor = DummyControl::New(true);
2140 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2141 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2142 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2143 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2144 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2145 application.GetScene().Add(actor);
2147 application.SendNotification();
2148 application.Render(0);
2149 application.SendNotification();
2151 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2153 for(int step_iter = 0; step_iter < 3; step_iter++)
2155 application.SendNotification();
2156 application.Render(0);
2157 application.Render(750u); // step i/4
2158 application.SendNotification();
2160 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2161 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2162 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2163 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2164 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2165 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2166 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2169 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2170 application.Render(750u); // go to end
2171 application.SendNotification();
2173 application.Render(10u); // finish
2174 application.SendNotification();
2177 application.SendNotification();
2178 application.Render(0u);
2179 application.SendNotification();
2185 int UtcDaliVisualAnimatedGradientVisual02(void)
2187 ToolkitTestApplication application;
2188 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2190 static std::vector<UniformData> customUniforms =
2192 UniformData("start_point", Property::Type::VECTOR2),
2193 UniformData("end_point", Property::Type::VECTOR2),
2194 UniformData("start_color", Property::Type::VECTOR4),
2195 UniformData("end_color", Property::Type::VECTOR4),
2196 UniformData("rotate_center", Property::Type::VECTOR2),
2197 UniformData("rotate_angle", Property::Type::FLOAT),
2198 UniformData("gradient_offset", Property::Type::FLOAT),
2201 TestGraphicsController& graphics = application.GetGraphicsController();
2202 graphics.AddCustomUniforms(customUniforms);
2205 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
2206 int _direction[2] = {0, 1};
2207 int _loop_count[3] = {-1, 0, 1};
2208 int _motion[2] = {0, 1};
2209 int _easing[4] = {0, 1, 2, 3};
2211 int test_case_max = 4 * 2 * 3 * 2 * 4;
2213 int test_case_d = 7; // 7 is the number of animated properties.
2215 float _duration = 0.4f;
2216 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2217 float noise_maker = 0.0f;
2218 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2219 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2221 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2223 VisualFactory factory = VisualFactory::Get();
2224 Property::Map propertyMap;
2225 Property::Map animationMap;
2226 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2228 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2229 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2230 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2232 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& {
2233 int tc = (test_case + tc_offset);
2234 int idx_easing = tc % 4;
2236 int idx_motion = tc % 2;
2238 int idx_loop_count = tc % 3;
2240 int idx_direction = tc % 2;
2242 int idx_delay = tc % 4;
2245 float duration = _duration - _repeat_delay;
2246 float repeat_delay = _repeat_delay;
2247 float delay = _delay[idx_delay] * _duration;
2248 int direction = _direction[idx_direction];
2249 int loop_count = _loop_count[idx_loop_count];
2250 int motion = _motion[idx_motion];
2251 int easing = _easing[idx_easing];
2253 animationMap.Clear();
2254 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2255 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2258 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2262 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2264 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2265 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2266 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2267 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2270 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2274 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2278 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2280 else if(easing == 1)
2282 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2284 else if(easing == 2)
2286 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2290 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2293 return animationMap;
2296 // Give different values for debuging
2297 noise_maker += 1.0f;
2298 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2299 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2300 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2301 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2302 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2303 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2304 float offset1 = 0.f + noise_maker * 0.1f;
2306 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2307 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2308 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2309 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2310 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2311 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2312 float offset2 = 2.f + noise_maker * 0.1f;
2314 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2315 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2316 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2318 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2319 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2320 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2321 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2322 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2323 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2324 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2326 Visual::Base visual = factory.CreateVisual(propertyMap);
2328 DummyControl actor = DummyControl::New(true);
2329 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2330 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2331 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2332 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2333 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2334 application.GetScene().Add(actor);
2336 application.SendNotification();
2337 application.Render(0);
2338 application.SendNotification();
2340 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2342 application.SendNotification();
2344 //Compare between CPU calculated value and Shader Visual calculated value
2345 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 {
2346 int tc = (test_case + tc_offset);
2347 int idx_easing = tc % 4;
2349 int idx_motion = tc % 2;
2351 int idx_loop_count = tc % 3;
2353 int idx_direction = tc % 2;
2355 int idx_delay = tc % 4;
2358 float duration = _duration - _repeat_delay;
2359 float repeat_delay = _repeat_delay;
2360 float delay = _delay[idx_delay] * _duration;
2361 int direction = _direction[idx_direction];
2362 int loop_count = _loop_count[idx_loop_count];
2363 int motion = _motion[idx_motion];
2364 int easing = _easing[idx_easing];
2366 progress -= delay / _duration;
2368 Property::Value s = start;
2369 Property::Value t = target;
2375 float x; ///< Animator progress value
2380 else if(loop_count > 0 && progress + 0.01f > loop_count)
2382 x = (motion == 0) ? 1.0f : 0.0f;
2390 progress = fmodf(progress, 1.0f);
2391 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2396 x = progress * 2.0f;
2403 if(easing == 1) // EASE_IN
2407 else if(easing == 2) // EASE_OUT
2409 x = 2.0f * x - x * x;
2411 else if(easing == 3) // EASE_IN_OUT
2413 x = x * x * (3.0f - 2.0f * x);
2416 if(value_type == 0) // result type is Float
2420 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2421 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2422 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2424 else if(value_type == 1) // result type is Vector2
2428 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2429 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2430 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2432 else if(value_type == 2) // result type is Vector3
2436 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2437 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2438 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2440 else // result type is Vector4
2444 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2445 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2446 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2451 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2453 for(int step_iter = 0; step_iter < 3; step_iter++)
2455 application.SendNotification();
2456 application.Render(_duration * 250.f); // step i/4
2457 application.SendNotification();
2460 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2461 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2462 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2463 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2464 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2465 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2466 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2468 application.SendNotification();
2469 application.Render(_duration * 250.f); // step 4/4 will not test
2470 application.SendNotification();
2474 application.SendNotification();
2476 application.SendNotification();
2477 application.Render(10.f); // tempral time
2478 application.SendNotification();
2485 int UtcDaliVisualAnimatedGradientVisual03(void)
2487 ToolkitTestApplication application;
2488 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2490 static std::vector<UniformData> customUniforms =
2492 UniformData("start_point", Property::Type::VECTOR2),
2493 UniformData("end_point", Property::Type::VECTOR2),
2494 UniformData("start_color", Property::Type::VECTOR4),
2495 UniformData("end_color", Property::Type::VECTOR4),
2496 UniformData("rotate_center", Property::Type::VECTOR2),
2497 UniformData("rotate_angle", Property::Type::FLOAT),
2498 UniformData("gradient_offset", Property::Type::FLOAT),
2501 TestGraphicsController& graphics = application.GetGraphicsController();
2502 graphics.AddCustomUniforms(customUniforms);
2505 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
2506 int _direction[2] = {0, 1};
2507 int _loop_count[3] = {-1, 0, 1};
2508 int _motion[2] = {0, 1};
2509 int _easing[4] = {0, 1, 2, 3};
2511 int test_case_max = 4 * 2 * 3 * 2 * 4;
2513 int test_case_d = 7; // 7 is the number of animated properties.
2515 float _duration = 0.4f;
2516 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2517 float noise_maker = 0.2f;
2518 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2519 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2521 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2523 VisualFactory factory = VisualFactory::Get();
2524 Property::Map propertyMap;
2525 Property::Map animationMap;
2526 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2528 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& {
2529 int tc = (test_case + tc_offset);
2530 int idx_easing = tc % 4;
2532 int idx_motion = tc % 2;
2534 int idx_loop_count = tc % 3;
2536 int idx_direction = tc % 2;
2538 int idx_delay = tc % 4;
2541 float duration = _duration - _repeat_delay;
2542 float repeat_delay = _repeat_delay;
2543 float delay = _delay[idx_delay] * _duration;
2544 int direction = _direction[idx_direction];
2545 int loop_count = _loop_count[idx_loop_count];
2546 int motion = _motion[idx_motion];
2547 int easing = _easing[idx_easing];
2549 animationMap.Clear();
2550 animationMap.Insert("startValue", start);
2551 animationMap.Insert("targetValue", target);
2554 animationMap.Insert("directionType", "FORWARD");
2558 animationMap.Insert("directionType", "BACKWARD");
2560 animationMap.Insert("duration", duration);
2561 animationMap.Insert("delay", delay);
2562 animationMap.Insert("repeat", loop_count);
2563 animationMap.Insert("repeatDelay", repeat_delay);
2566 animationMap.Insert("motionType", "LOOP");
2570 animationMap.Insert("motionType", "MIRROR");
2574 animationMap.Insert("easingType", "LINEAR");
2576 else if(easing == 1)
2578 animationMap.Insert("easingType", "IN");
2580 else if(easing == 2)
2582 animationMap.Insert("easingType", "OUT");
2586 animationMap.Insert("easingType", "IN_OUT");
2589 return animationMap;
2592 // Give different values for debuging
2593 noise_maker += 0.8f;
2594 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2595 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2596 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2597 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2598 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2599 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2600 float offset1 = 0.f + noise_maker * 0.1f;
2602 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2603 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2604 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2605 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2606 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2607 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2608 float offset2 = 2.f + noise_maker * 0.1f;
2610 propertyMap.Insert("gradientType", "LINEAR");
2611 propertyMap.Insert("unitType", "USER_SPACE");
2612 propertyMap.Insert("spreadType", "CLAMP");
2614 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2615 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2616 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2617 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2618 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2619 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2620 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2622 Visual::Base visual = factory.CreateVisual(propertyMap);
2624 DummyControl actor = DummyControl::New(true);
2625 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2626 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2627 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2628 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2629 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2630 application.GetScene().Add(actor);
2632 application.SendNotification();
2633 application.Render(0);
2634 application.SendNotification();
2636 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2638 application.SendNotification();
2640 //Compare between CPU calculated value and Shader Visual calculated value
2641 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 {
2642 int tc = (test_case + tc_offset);
2643 int idx_easing = tc % 4;
2645 int idx_motion = tc % 2;
2647 int idx_loop_count = tc % 3;
2649 int idx_direction = tc % 2;
2651 int idx_delay = tc % 4;
2654 float duration = _duration - _repeat_delay;
2655 float repeat_delay = _repeat_delay;
2656 float delay = _delay[idx_delay] * _duration;
2657 int direction = _direction[idx_direction];
2658 int loop_count = _loop_count[idx_loop_count];
2659 int motion = _motion[idx_motion];
2660 int easing = _easing[idx_easing];
2662 progress -= delay / _duration;
2664 Property::Value s = start;
2665 Property::Value t = target;
2671 float x; ///< Animator progress value
2676 else if(loop_count > 0 && progress + 0.01f > loop_count)
2678 x = (motion == 0) ? 1.0f : 0.0f;
2686 progress = fmodf(progress, 1.0f);
2687 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2692 x = progress * 2.0f;
2699 if(easing == 1) // EASE_IN
2703 else if(easing == 2) // EASE_OUT
2705 x = 2.0f * x - x * x;
2707 else if(easing == 3) // EASE_IN_OUT
2709 x = x * x * (3.0f - 2.0f * x);
2712 if(value_type == 0) // result type is Float
2716 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2717 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2718 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2720 else if(value_type == 1) // result type is Vector2
2724 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2725 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2726 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2728 else if(value_type == 2) // result type is Vector3
2732 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2733 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2734 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2736 else // result type is Vector4
2740 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2741 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2742 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2747 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2749 for(int step_iter = 0; step_iter < 3; step_iter++)
2751 application.SendNotification();
2752 application.Render(_duration * 250.f); // step i/4
2753 application.SendNotification();
2756 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2757 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2758 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2759 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2760 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2761 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2762 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2764 application.SendNotification();
2765 application.Render(_duration * 250.f); // step 4/4 will not test
2766 application.SendNotification();
2770 application.SendNotification();
2772 application.SendNotification();
2773 application.Render(10.f); // tempral time
2774 application.SendNotification();
2781 int UtcDaliVisualWireframeVisual(void)
2783 ToolkitTestApplication application;
2785 VisualFactory factory = VisualFactory::Get();
2786 Property::Map propertyMap;
2787 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2789 // Create the visual.
2790 Visual::Base visual = factory.CreateVisual(propertyMap);
2792 DALI_TEST_CHECK(visual);
2794 Property::Map resultMap;
2795 visual.CreatePropertyMap(resultMap);
2797 // Check the property values from the returned map from visual
2798 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2799 DALI_TEST_CHECK(value);
2800 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2805 int UtcDaliVisualGetTransform(void)
2807 ToolkitTestApplication application;
2808 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2810 VisualFactory factory = VisualFactory::Get();
2811 Property::Map propertyMap;
2812 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2813 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2814 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2816 Dali::Property::Map visualMap;
2817 colorVisual.CreatePropertyMap(visualMap);
2818 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2819 Dali::Property::Map* map = value->GetMap();
2820 DALI_TEST_CHECK(map);
2822 //Test default values
2824 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2825 DALI_TEST_CHECK(typeValue);
2826 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2829 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2830 DALI_TEST_CHECK(typeValue);
2831 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2834 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2835 DALI_TEST_CHECK(typeValue);
2836 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2839 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2840 DALI_TEST_CHECK(typeValue);
2841 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2844 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2845 DALI_TEST_CHECK(typeValue);
2846 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2849 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2850 DALI_TEST_CHECK(typeValue);
2851 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2854 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2855 DALI_TEST_CHECK(typeValue);
2856 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2862 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2864 Property::Map transform;
2865 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2866 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2867 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2868 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2869 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2870 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2872 visual.SetTransformAndSize(transform, Vector2(100, 100));
2874 Dali::Property::Map visualMap;
2875 visual.CreatePropertyMap(visualMap);
2876 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2877 Dali::Property::Map* map = value->GetMap();
2878 DALI_TEST_CHECK(map);
2881 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2882 DALI_TEST_CHECK(typeValue);
2883 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2886 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2887 DALI_TEST_CHECK(typeValue);
2888 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2891 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2892 DALI_TEST_CHECK(typeValue);
2893 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2896 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2897 DALI_TEST_CHECK(typeValue);
2898 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2901 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2902 DALI_TEST_CHECK(typeValue);
2903 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2906 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2907 DALI_TEST_CHECK(typeValue);
2908 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2911 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2912 DALI_TEST_CHECK(typeValue);
2913 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2916 //Put the visual on the stage
2917 DummyControl actor = DummyControl::New(true);
2918 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2919 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2920 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2921 application.GetScene().Add(actor);
2923 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2924 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2926 application.SendNotification();
2927 application.Render(0);
2928 Renderer renderer(actor.GetRendererAt(0));
2930 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2931 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2933 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2934 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2936 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2937 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2939 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2940 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2942 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2943 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2945 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2946 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2948 //Set a new transform
2950 transform = DefaultTransform();
2951 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2952 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2953 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2954 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2955 visual.SetTransformAndSize(transform, Vector2(100, 100));
2956 application.SendNotification();
2957 application.Render(0);
2959 //Check that the values have changed in the renderer
2960 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2961 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2963 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2964 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2966 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2967 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2969 //Parent origin and anchor point should have the default values
2970 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2971 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2973 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2974 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2976 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2977 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2980 int UtcDaliVisualSetTransform01(void)
2982 ToolkitTestApplication application;
2983 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2985 VisualFactory factory = VisualFactory::Get();
2986 Property::Map propertyMap;
2987 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2988 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2989 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2990 Visual::Base visual = factory.CreateVisual(propertyMap);
2991 TestTransform(application, visual);
2992 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2997 int UtcDaliVisualSetTransform0(void)
2999 ToolkitTestApplication application;
3000 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3002 VisualFactory factory = VisualFactory::Get();
3003 Property::Map propertyMap;
3004 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3005 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3006 Visual::Base visual = factory.CreateVisual(propertyMap);
3007 TestTransform(application, visual);
3008 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3013 int UtcDaliVisualSetTransform1(void)
3015 ToolkitTestApplication application;
3016 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3018 VisualFactory factory = VisualFactory::Get();
3019 Property::Map propertyMap;
3020 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3021 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3022 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3023 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3024 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3025 Visual::Base visual = factory.CreateVisual(propertyMap);
3026 TestTransform(application, visual);
3027 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3032 int UtcDaliVisualSetTransform2(void)
3034 ToolkitTestApplication application;
3035 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3037 VisualFactory factory = VisualFactory::Get();
3038 Property::Map propertyMap;
3039 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3040 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3042 Property::Array stopOffsets;
3043 stopOffsets.PushBack(0.0f);
3044 stopOffsets.PushBack(0.3f);
3045 stopOffsets.PushBack(0.6f);
3046 stopOffsets.PushBack(0.8f);
3047 stopOffsets.PushBack(1.0f);
3048 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3050 Property::Array stopColors;
3051 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3052 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3053 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3054 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3055 stopColors.PushBack(Color::YELLOW);
3056 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3057 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3058 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3059 Visual::Base visual = factory.CreateVisual(propertyMap);
3060 TestTransform(application, visual);
3061 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3066 int UtcDaliVisualSetTransform3(void)
3068 ToolkitTestApplication application;
3069 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3071 VisualFactory factory = VisualFactory::Get();
3072 Property::Map propertyMap;
3073 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3074 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3075 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3076 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3077 Visual::Base visual = factory.CreateVisual(propertyMap);
3078 TestTransform(application, visual);
3079 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3084 int UtcDaliVisualSetTransform4(void)
3086 ToolkitTestApplication application;
3087 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3089 VisualFactory factory = VisualFactory::Get();
3090 Property::Map propertyMap;
3091 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3092 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3094 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3095 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3096 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3097 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3098 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3099 Visual::Base visual = factory.CreateVisual(propertyMap);
3100 TestTransform(application, visual);
3101 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3106 int UtcDaliVisualSetTransform5(void)
3108 ToolkitTestApplication application;
3109 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3111 VisualFactory factory = VisualFactory::Get();
3112 Property::Map propertyMap;
3113 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3114 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3115 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3116 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3117 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3118 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3119 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3120 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3121 Visual::Base visual = factory.CreateVisual(propertyMap);
3122 TestTransform(application, visual);
3123 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3128 int UtcDaliVisualSetTransform6(void)
3130 ToolkitTestApplication application;
3131 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3133 VisualFactory factory = VisualFactory::Get();
3134 Property::Map propertyMap;
3135 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3136 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3137 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3138 Visual::Base visual = factory.CreateVisual(propertyMap);
3139 TestTransform(application, visual);
3140 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3145 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3147 ToolkitTestApplication application;
3148 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3150 VisualFactory factory = VisualFactory::Get();
3151 Property::Map propertyMap;
3152 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3153 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3154 Visual::Base visual = factory.CreateVisual(propertyMap);
3156 Property::Map transform;
3157 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3158 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3159 visual.SetTransformAndSize(transform, Vector2(100, 100));
3161 Dali::Property::Map visualMap;
3162 visual.CreatePropertyMap(visualMap);
3163 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3164 Dali::Property::Map* map = value->GetMap();
3165 DALI_TEST_CHECK(map);
3168 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3169 DALI_TEST_CHECK(typeValue);
3170 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3173 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3174 DALI_TEST_CHECK(typeValue);
3175 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3181 int UtcDaliNPatchVisualCustomShader(void)
3183 ToolkitTestApplication application;
3184 tet_infoline("NPatchVisual with custom shader");
3186 VisualFactory factory = VisualFactory::Get();
3187 Property::Map properties;
3188 Property::Map shader;
3189 const std::string vertexShader = "Foobar";
3190 const std::string fragmentShader = "Foobar";
3191 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3192 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3194 Property::Map transformMap;
3195 transformMap["size"] = Vector2(0.5f, 0.5f);
3196 transformMap["offset"] = Vector2(20.0f, 0.0f);
3197 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3198 transformMap["anchorPoint"] = Align::CENTER;
3199 transformMap["origin"] = Align::CENTER;
3200 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3201 properties[Visual::Property::TRANSFORM] = transformMap;
3203 properties[Visual::Property::TYPE] = Visual::IMAGE;
3204 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3205 properties[Visual::Property::SHADER] = shader;
3206 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3207 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3209 Visual::Base visual = factory.CreateVisual(properties);
3210 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3212 // trigger creation through setting on stage
3213 DummyControl dummy = DummyControl::New(true);
3214 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3215 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3216 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3217 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3218 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3219 application.GetScene().Add(dummy);
3220 application.SendNotification();
3222 Renderer renderer = dummy.GetRendererAt(0);
3223 Shader shader2 = renderer.GetShader();
3224 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3225 Property::Map* map = value.GetMap();
3226 DALI_TEST_CHECK(map);
3228 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3229 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3231 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3232 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3234 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3235 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3237 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3238 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3243 int UtcDaliGradientVisualBlendMode(void)
3245 ToolkitTestApplication application;
3246 VisualFactory factory = VisualFactory::Get();
3248 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3249 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)));
3251 Visual::Base alphaGradientVisual = factory.CreateVisual(
3252 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))));
3254 DummyControl control = DummyControl::New(true);
3255 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3256 application.GetScene().Add(control);
3258 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3259 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3260 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3262 application.SendNotification();
3263 application.Render();
3265 // 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
3266 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3267 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3268 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3273 int UtcDaliVisualRendererRemovalAndReAddition(void)
3275 ToolkitTestApplication application;
3276 tet_infoline("UtcDaliVisualRendererRemoval");
3278 VisualFactory factory = VisualFactory::Get();
3279 Property::Map propertyMap;
3280 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3281 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3282 Visual::Base visual = factory.CreateVisual(propertyMap);
3284 visual.SetDepthIndex(1);
3286 DummyControl dummyControl = DummyControl::New(true);
3287 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3288 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3289 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3291 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3292 tet_infoline("Add control with visual to stage and check renderer count is 1");
3294 application.GetScene().Add(dummyControl);
3296 application.SendNotification();
3297 application.Render();
3299 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3301 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3302 application.GetScene().Remove(dummyControl);
3303 application.SendNotification();
3304 application.Render();
3306 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3308 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3310 application.GetScene().Add(dummyControl);
3312 application.SendNotification();
3313 application.Render();
3315 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3320 int UtcDaliVisualTextVisualRender(void)
3322 ToolkitTestApplication application;
3323 tet_infoline("UtcDaliVisualTextVisualRender");
3325 VisualFactory factory = VisualFactory::Get();
3326 Property::Map propertyMap;
3327 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3328 propertyMap.Insert("mixColor", Color::WHITE);
3329 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3330 propertyMap.Insert("enableMarkup", false);
3331 propertyMap.Insert("text", "Hello world");
3332 propertyMap.Insert("fontFamily", "TizenSans");
3334 Property::Map fontStyleMapSet;
3335 fontStyleMapSet.Insert("weight", "bold");
3336 propertyMap.Insert("fontStyle", fontStyleMapSet);
3338 propertyMap.Insert("pointSize", 12.f);
3339 propertyMap.Insert("multiLine", true);
3340 propertyMap.Insert("horizontalAlignment", "CENTER");
3341 propertyMap.Insert("verticalAlignment", "CENTER");
3342 propertyMap.Insert("textColor", Color::RED);
3343 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3344 textVisual.SetDepthIndex(1);
3346 DummyControl dummyControl = DummyControl::New(true);
3347 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3348 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3349 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3351 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3352 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3354 application.GetScene().Add(dummyControl);
3355 application.SendNotification();
3356 application.Render();
3358 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3359 propertyMap.Clear();
3360 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3361 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3362 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3363 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3365 Property::Map transformMap;
3366 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3367 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3369 textVisual = factory.CreateVisual(propertyMap);
3370 textVisual.SetDepthIndex(1);
3372 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3373 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3375 application.SendNotification(); // force process events to ensure text visual
3376 // adds renderer to the dummy control in OnRelayout
3377 application.Render();
3379 Renderer renderer = dummyControl.GetRendererAt(0u);
3380 Property::Index index = renderer.GetPropertyIndex("transformSize");
3382 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3383 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3388 int UtcDaliVisualTextVisualDisableEnable(void)
3390 ToolkitTestApplication application;
3391 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3393 VisualFactory factory = VisualFactory::Get();
3394 Property::Map propertyMap;
3395 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3396 propertyMap.Insert("mixColor", Color::WHITE);
3397 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3398 propertyMap.Insert("enableMarkup", false);
3399 propertyMap.Insert("text", "Hello world");
3400 propertyMap.Insert("fontFamily", "TizenSans");
3402 Property::Map fontStyleMapSet;
3403 fontStyleMapSet.Insert("weight", "bold");
3404 propertyMap.Insert("fontStyle", fontStyleMapSet);
3406 propertyMap.Insert("pointSize", 12.f);
3407 propertyMap.Insert("multiLine", true);
3408 propertyMap.Insert("horizontalAlignment", "CENTER");
3409 propertyMap.Insert("verticalAlignment", "CENTER");
3410 propertyMap.Insert("textColor", Color::RED);
3411 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3412 textVisual.SetDepthIndex(1);
3414 DummyControl dummyControl = DummyControl::New(true);
3415 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3416 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3417 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3419 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3420 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3422 application.GetScene().Add(dummyControl);
3423 application.SendNotification();
3424 application.Render();
3426 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3428 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3430 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3432 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3434 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3439 int UtcDaliVisualPremultipliedAlpha(void)
3441 ToolkitTestApplication application;
3442 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3444 VisualFactory factory = VisualFactory::Get();
3446 // image visual, test default value ( true )
3448 Visual::Base imageVisual = factory.CreateVisual(
3450 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3451 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3453 Dali::Property::Map visualMap;
3454 imageVisual.CreatePropertyMap(visualMap);
3455 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3458 DALI_TEST_CHECK(value);
3459 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3462 // image visual, override premultiplied
3464 Visual::Base imageVisual = factory.CreateVisual(
3466 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3467 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3468 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3470 Dali::Property::Map visualMap;
3471 imageVisual.CreatePropertyMap(visualMap);
3472 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3475 DALI_TEST_CHECK(value);
3476 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3479 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3481 Visual::Base imageVisual = factory.CreateVisual(
3483 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3484 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3486 Dali::Property::Map visualMap;
3487 imageVisual.CreatePropertyMap(visualMap);
3488 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3491 DALI_TEST_CHECK(value);
3492 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3495 Visual::Base imageVisual = factory.CreateVisual(
3497 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3498 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3499 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3501 Dali::Property::Map visualMap;
3502 imageVisual.CreatePropertyMap(visualMap);
3503 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3506 DALI_TEST_CHECK(value);
3507 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3510 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3512 Visual::Base imageVisual = factory.CreateVisual(
3514 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3515 .Add(ImageVisual::Property::URL, "something.json"));
3517 Dali::Property::Map visualMap;
3518 imageVisual.CreatePropertyMap(visualMap);
3519 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3522 DALI_TEST_CHECK(value);
3523 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3526 Visual::Base imageVisual = factory.CreateVisual(
3528 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3529 .Add(ImageVisual::Property::URL, "something.json")
3530 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3532 Dali::Property::Map visualMap;
3533 imageVisual.CreatePropertyMap(visualMap);
3534 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3537 DALI_TEST_CHECK(value);
3538 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3541 // text visual ( premultiplied alpha by default is true, and cannot change value )
3543 Visual::Base textVisual = factory.CreateVisual(
3545 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3546 .Add(TextVisual::Property::TEXT, "Text"));
3548 Dali::Property::Map visualMap;
3549 textVisual.CreatePropertyMap(visualMap);
3550 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3553 DALI_TEST_CHECK(value);
3554 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3557 Visual::Base textVisual = factory.CreateVisual(
3559 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3560 .Add(TextVisual::Property::TEXT, "Text")
3561 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3563 Dali::Property::Map visualMap;
3564 textVisual.CreatePropertyMap(visualMap);
3565 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3568 DALI_TEST_CHECK(value);
3569 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3572 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3574 Visual::Base gradientVisual = factory.CreateVisual(
3576 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3577 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3578 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3579 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3581 Dali::Property::Map visualMap;
3582 gradientVisual.CreatePropertyMap(visualMap);
3583 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3586 DALI_TEST_CHECK(value);
3587 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3590 Visual::Base gradientVisual = factory.CreateVisual(
3592 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3593 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3594 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3595 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3596 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3598 Dali::Property::Map visualMap;
3599 gradientVisual.CreatePropertyMap(visualMap);
3600 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3603 DALI_TEST_CHECK(value);
3604 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3607 // color visual ( premultiplied alpha by default is false, and cannot change value )
3609 Visual::Base colorVisual = factory.CreateVisual(
3611 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3612 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3614 Dali::Property::Map visualMap;
3615 colorVisual.CreatePropertyMap(visualMap);
3616 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3619 DALI_TEST_CHECK(value);
3620 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3623 Visual::Base colorVisual = factory.CreateVisual(
3625 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3626 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3627 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3629 Dali::Property::Map visualMap;
3630 colorVisual.CreatePropertyMap(visualMap);
3631 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3634 DALI_TEST_CHECK(value);
3635 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3641 int UtcDaliRegisterVisualOrder(void)
3643 ToolkitTestApplication application;
3644 tet_infoline("Register Visual Order");
3646 DummyControl dummyControl = DummyControl::New(true);
3647 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3649 VisualFactory factory = VisualFactory::Get();
3650 Property::Map propertyMap;
3651 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3652 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3654 tet_infoline("Register visual, should have depth index of 0.0f");
3655 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3656 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3657 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3659 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3661 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3662 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3663 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3665 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3666 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3667 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3669 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3670 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3671 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3673 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3674 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3675 labelVisual.SetDepthIndex(-2000);
3676 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3677 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3679 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3680 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3681 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3682 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3683 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3684 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3686 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3687 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3688 anotherTestVisual2Replacement.SetDepthIndex(2000);
3689 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3690 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3692 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3693 application.GetScene().Add(dummyControl);
3698 int UtcDaliRegisterVisualOrder02(void)
3700 ToolkitTestApplication application;
3701 tet_infoline("Register Visual Order with Background Set");
3703 DummyControl dummyControl = DummyControl::New(true);
3704 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3706 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3708 VisualFactory factory = VisualFactory::Get();
3709 Property::Map propertyMap;
3710 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3711 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3713 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3715 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3717 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3718 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3719 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3720 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3721 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3723 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3724 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3725 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3726 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3728 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3729 application.GetScene().Add(dummyControl);
3734 int UtcDaliRegisterVisualWithDepthIndex(void)
3736 ToolkitTestApplication application;
3737 tet_infoline("Register a Visual With Depth Index");
3739 DummyControl dummyControl = DummyControl::New(true);
3740 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3742 VisualFactory factory = VisualFactory::Get();
3743 Property::Map propertyMap;
3744 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3745 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3747 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3748 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3749 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3750 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3751 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3753 tet_infoline("Register another visual with a depth index and it disabled");
3754 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3755 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3756 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3757 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3759 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3760 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3761 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3762 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3763 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3765 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3766 application.GetScene().Add(dummyControl);
3771 int UtcDaliSvgVisualCustomShader(void)
3773 ToolkitTestApplication application;
3774 tet_infoline("SvgVisual with custom shader");
3776 VisualFactory factory = VisualFactory::Get();
3777 Property::Map properties;
3778 Property::Map shader;
3779 const std::string vertexShader = "Foobar";
3780 const std::string fragmentShader = "Foobar";
3781 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3782 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3784 properties[Visual::Property::TYPE] = Visual::IMAGE;
3785 properties[Visual::Property::SHADER] = shader;
3786 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3788 Visual::Base visual = factory.CreateVisual(properties);
3790 // trigger creation through setting on stage
3791 DummyControl dummy = DummyControl::New(true);
3792 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3793 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3795 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3796 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3797 application.GetScene().Add(dummy);
3799 application.SendNotification();
3800 application.Render();
3802 // Wait for loading & rasterization
3803 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3805 Renderer renderer = dummy.GetRendererAt(0);
3806 Shader shader2 = renderer.GetShader();
3807 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3808 Property::Map* map = value.GetMap();
3809 DALI_TEST_CHECK(map);
3811 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3812 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3814 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3815 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3820 int UtcDaliVisualRoundedCorner(void)
3822 tet_infoline("UtcDaliVisualRoundedCorner");
3824 static std::vector<UniformData> customUniforms =
3826 UniformData("cornerRadius", Property::Type::VECTOR4),
3827 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3832 ToolkitTestApplication application;
3833 TestGraphicsController& graphics = application.GetGraphicsController();
3834 graphics.AddCustomUniforms(customUniforms);
3836 VisualFactory factory = VisualFactory::Get();
3837 Property::Map properties;
3838 float cornerRadius = 30.0f;
3840 properties[Visual::Property::TYPE] = Visual::IMAGE;
3841 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3842 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3844 Visual::Base visual = factory.CreateVisual(properties);
3846 // trigger creation through setting on stage
3847 DummyControl dummy = DummyControl::New(true);
3848 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3849 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3851 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3852 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3853 application.GetScene().Add(dummy);
3855 application.SendNotification();
3856 application.Render();
3858 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3860 application.SendNotification();
3861 application.Render();
3863 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3864 // Default corner radius policy is absolute.
3865 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3870 ToolkitTestApplication application;
3871 TestGraphicsController& graphics = application.GetGraphicsController();
3872 graphics.AddCustomUniforms(customUniforms);
3874 VisualFactory factory = VisualFactory::Get();
3875 Property::Map properties;
3876 float cornerRadius = 30.0f;
3878 properties[Visual::Property::TYPE] = Visual::COLOR;
3879 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3880 properties["cornerRadius"] = cornerRadius;
3881 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3883 Visual::Base visual = factory.CreateVisual(properties);
3885 // trigger creation through setting on stage
3886 DummyControl dummy = DummyControl::New(true);
3887 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3888 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3890 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3891 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3892 application.GetScene().Add(dummy);
3894 application.SendNotification();
3895 application.Render();
3897 application.SendNotification();
3898 application.Render();
3900 // Currently test with multiple program doesn't work well. will fix another day
3901 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3902 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3907 ToolkitTestApplication application;
3908 TestGraphicsController& graphics = application.GetGraphicsController();
3909 graphics.AddCustomUniforms(customUniforms);
3911 VisualFactory factory = VisualFactory::Get();
3912 Property::Map properties;
3913 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3915 properties[Visual::Property::TYPE] = Visual::COLOR;
3916 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3917 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3918 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3920 Visual::Base visual = factory.CreateVisual(properties);
3922 // trigger creation through setting on stage
3923 DummyControl dummy = DummyControl::New(true);
3924 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3925 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3927 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3928 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3929 application.GetScene().Add(dummy);
3931 application.SendNotification();
3932 application.Render();
3934 application.SendNotification();
3935 application.Render();
3937 // Currently test with multiple program doesn't work well. will fix another day
3938 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3939 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3942 // color visual 3 - invalid value
3944 ToolkitTestApplication application;
3945 TestGraphicsController& graphics = application.GetGraphicsController();
3946 graphics.AddCustomUniforms(customUniforms);
3948 VisualFactory factory = VisualFactory::Get();
3949 Property::Map properties;
3950 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3952 properties[Visual::Property::TYPE] = Visual::COLOR;
3953 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3954 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3955 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3957 Visual::Base visual = factory.CreateVisual(properties);
3959 // trigger creation through setting on stage
3960 DummyControl dummy = DummyControl::New(true);
3961 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3962 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3964 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3965 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3966 application.GetScene().Add(dummy);
3968 application.SendNotification();
3969 application.Render();
3971 application.SendNotification();
3972 application.Render();
3974 // Currently test with multiple program doesn't work well. will fix another day
3975 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3976 // Default corner radius policy is absolute.
3977 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3982 ToolkitTestApplication application;
3983 TestGraphicsController& graphics = application.GetGraphicsController();
3984 graphics.AddCustomUniforms(customUniforms);
3986 VisualFactory factory = VisualFactory::Get();
3987 Property::Map properties;
3988 float cornerRadius = 30.0f;
3990 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3991 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3992 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3993 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3994 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3995 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3997 Property::Array stopOffsets;
3998 stopOffsets.PushBack(0.0f);
3999 stopOffsets.PushBack(0.6f);
4000 stopOffsets.PushBack(1.0f);
4001 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4003 Property::Array stopColors;
4004 stopColors.PushBack(Color::RED);
4005 stopColors.PushBack(Color::YELLOW);
4006 stopColors.PushBack(Color::GREEN);
4007 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4009 Visual::Base visual = factory.CreateVisual(properties);
4011 // trigger creation through setting on stage
4012 DummyControl dummy = DummyControl::New(true);
4013 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4014 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4016 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4017 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4018 application.GetScene().Add(dummy);
4020 application.SendNotification();
4021 application.Render();
4023 application.SendNotification();
4024 application.Render();
4026 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4027 // Default corner radius policy is absolute.
4028 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4031 // animated image visual
4033 ToolkitTestApplication application;
4034 TestGraphicsController& graphics = application.GetGraphicsController();
4035 graphics.AddCustomUniforms(customUniforms);
4037 VisualFactory factory = VisualFactory::Get();
4038 Property::Map properties;
4039 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4041 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4042 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4043 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4044 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4045 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4047 Visual::Base visual = factory.CreateVisual(properties);
4049 // trigger creation through setting on stage
4050 DummyControl dummy = DummyControl::New(true);
4051 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4052 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4054 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4055 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4056 application.GetScene().Add(dummy);
4058 application.SendNotification();
4059 application.Render();
4061 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4063 application.SendNotification();
4064 application.Render();
4066 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4067 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4070 // vector image visual
4072 ToolkitTestApplication application;
4073 TestGraphicsController& graphics = application.GetGraphicsController();
4074 graphics.AddCustomUniforms(customUniforms);
4076 VisualFactory factory = VisualFactory::Get();
4077 Property::Map properties;
4078 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4080 properties[Visual::Property::TYPE] = Visual::SVG;
4081 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4082 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4084 Visual::Base visual = factory.CreateVisual(properties);
4086 // trigger creation through setting on stage
4087 DummyControl dummy = DummyControl::New(true);
4088 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4089 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4091 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4092 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4093 application.GetScene().Add(dummy);
4095 application.SendNotification();
4096 application.Render();
4098 // Wait for loading & rasterization
4099 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4101 application.SendNotification();
4102 application.Render();
4104 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4105 // Default corner radius policy is absolute.
4106 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4109 // animated vector image visual
4111 ToolkitTestApplication application;
4112 TestGraphicsController& graphics = application.GetGraphicsController();
4113 graphics.AddCustomUniforms(customUniforms);
4115 VisualFactory factory = VisualFactory::Get();
4116 Property::Map properties;
4117 float cornerRadius = 1.3f;
4119 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4120 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4121 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4122 properties["cornerRadius"] = cornerRadius;
4123 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4125 Visual::Base visual = factory.CreateVisual(properties);
4127 // trigger creation through setting on stage
4128 DummyControl dummy = DummyControl::New(true);
4129 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4130 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4132 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4133 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4134 application.GetScene().Add(dummy);
4136 application.SendNotification();
4137 application.Render();
4139 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4141 application.SendNotification();
4142 application.Render();
4144 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4145 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4151 int UtcDaliVisualBorderline(void)
4153 tet_infoline("UtcDaliVisualBorderline");
4155 static std::vector<UniformData> customUniforms =
4157 UniformData("cornerRadius", Property::Type::VECTOR4),
4158 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4159 UniformData("borderlineWidth", Property::Type::FLOAT),
4160 UniformData("borderlineColor", Property::Type::VECTOR4),
4161 UniformData("borderlineOffset", Property::Type::FLOAT),
4166 ToolkitTestApplication application;
4167 TestGraphicsController& graphics = application.GetGraphicsController();
4168 graphics.AddCustomUniforms(customUniforms);
4170 VisualFactory factory = VisualFactory::Get();
4171 Property::Map properties;
4172 float cornerRadius = 5.0f;
4173 float borderlineWidth = 30.0f;
4174 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4175 float borderlineOffset = 1.0f;
4177 properties[Visual::Property::TYPE] = Visual::IMAGE;
4178 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4179 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4180 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4181 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4182 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4184 Visual::Base visual = factory.CreateVisual(properties);
4186 // trigger creation through setting on stage
4187 DummyControl dummy = DummyControl::New(true);
4188 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4189 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4191 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4192 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4193 application.GetScene().Add(dummy);
4195 application.SendNotification();
4196 application.Render();
4198 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4200 application.SendNotification();
4201 application.Render();
4203 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4204 // Default corner radius policy is absolute.
4205 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4206 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4207 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4208 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4213 ToolkitTestApplication application;
4214 TestGraphicsController& graphics = application.GetGraphicsController();
4215 graphics.AddCustomUniforms(customUniforms);
4217 VisualFactory factory = VisualFactory::Get();
4218 Property::Map properties;
4219 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4220 float borderlineWidth = 30.0f;
4221 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4222 float borderlineOffset = -0.4f;
4224 properties[Visual::Property::TYPE] = Visual::COLOR;
4225 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4226 properties["cornerRadius"] = cornerRadius;
4227 properties["borderlineWidth"] = borderlineWidth;
4228 properties["borderlineColor"] = borderlineColor;
4229 properties["borderlineOffset"] = borderlineOffset;
4231 Visual::Base visual = factory.CreateVisual(properties);
4233 // trigger creation through setting on stage
4234 DummyControl dummy = DummyControl::New(true);
4235 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4236 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4238 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4239 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4240 application.GetScene().Add(dummy);
4242 application.SendNotification();
4243 application.Render();
4245 application.SendNotification();
4246 application.Render();
4248 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4249 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4250 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4251 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4254 // color visual 2, default color, default offset
4256 ToolkitTestApplication application;
4257 TestGraphicsController& graphics = application.GetGraphicsController();
4258 graphics.AddCustomUniforms(customUniforms);
4260 VisualFactory factory = VisualFactory::Get();
4261 Property::Map properties;
4262 float borderlineWidth = 30.0f;
4264 properties[Visual::Property::TYPE] = Visual::COLOR;
4265 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4266 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4268 Visual::Base visual = factory.CreateVisual(properties);
4270 // trigger creation through setting on stage
4271 DummyControl dummy = DummyControl::New(true);
4272 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4273 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4275 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4276 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4277 application.GetScene().Add(dummy);
4279 application.SendNotification();
4280 application.Render();
4282 application.SendNotification();
4283 application.Render();
4285 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4286 // Default borderline color is BLACK.
4287 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4288 // Default borderline offset is 0.0f.
4289 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4292 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4294 ToolkitTestApplication application;
4295 TestGraphicsController& graphics = application.GetGraphicsController();
4296 graphics.AddCustomUniforms(customUniforms);
4298 VisualFactory factory = VisualFactory::Get();
4299 Property::Map properties;
4300 float borderlineWidth = 30.0f;
4301 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4302 float borderlineOffset = 37.4f;
4304 properties[Visual::Property::TYPE] = Visual::COLOR;
4305 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4306 properties["borderlineWidth"] = borderlineWidth;
4307 properties["borderlineColor"] = borderlineColor;
4308 properties["borderlineOffset"] = borderlineOffset;
4310 Visual::Base visual = factory.CreateVisual(properties);
4312 // trigger creation through setting on stage
4313 DummyControl dummy = DummyControl::New(true);
4314 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4315 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4317 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4318 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4319 application.GetScene().Add(dummy);
4321 application.SendNotification();
4322 application.Render();
4324 application.SendNotification();
4325 application.Render();
4327 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4328 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4329 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4330 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4335 ToolkitTestApplication application;
4336 TestGraphicsController& graphics = application.GetGraphicsController();
4337 graphics.AddCustomUniforms(customUniforms);
4339 VisualFactory factory = VisualFactory::Get();
4340 Property::Map properties;
4341 float borderlineWidth = 30.0f;
4342 float cornerRadius = 70.0f;
4344 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4345 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4346 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4347 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4348 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4349 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4350 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4352 Property::Array stopOffsets;
4353 stopOffsets.PushBack(0.0f);
4354 stopOffsets.PushBack(0.6f);
4355 stopOffsets.PushBack(1.0f);
4356 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4358 Property::Array stopColors;
4359 stopColors.PushBack(Color::RED);
4360 stopColors.PushBack(Color::YELLOW);
4361 stopColors.PushBack(Color::GREEN);
4362 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4364 Visual::Base visual = factory.CreateVisual(properties);
4366 // trigger creation through setting on stage
4367 DummyControl dummy = DummyControl::New(true);
4368 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4369 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4371 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4372 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4373 application.GetScene().Add(dummy);
4375 application.SendNotification();
4376 application.Render();
4378 application.SendNotification();
4379 application.Render();
4381 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4382 // Default corner radius policy is absolute.
4383 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4384 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4385 // Default borderline color is BLACK.
4386 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4387 // Default borderline offset is 0.0f.
4388 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4391 // animated image visual
4393 ToolkitTestApplication application;
4394 TestGraphicsController& graphics = application.GetGraphicsController();
4395 graphics.AddCustomUniforms(customUniforms);
4397 VisualFactory factory = VisualFactory::Get();
4398 Property::Map properties;
4399 float borderlineWidth = 24.0f;
4400 float borderlineOffset = -1.0f;
4402 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4403 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4404 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4405 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4406 properties["borderlineOffset"] = borderlineOffset;
4408 Visual::Base visual = factory.CreateVisual(properties);
4410 // trigger creation through setting on stage
4411 DummyControl dummy = DummyControl::New(true);
4412 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4413 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4415 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4416 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4417 application.GetScene().Add(dummy);
4419 application.SendNotification();
4420 application.Render();
4422 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4424 application.SendNotification();
4425 application.Render();
4427 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4428 // Default borderline color is BLACK.
4429 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4430 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4433 // vector image visual
4435 ToolkitTestApplication application;
4436 TestGraphicsController& graphics = application.GetGraphicsController();
4437 graphics.AddCustomUniforms(customUniforms);
4439 VisualFactory factory = VisualFactory::Get();
4440 Property::Map properties;
4441 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4442 float borderlineWidth = 27.0f;
4443 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4445 properties[Visual::Property::TYPE] = Visual::SVG;
4446 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4447 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4448 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4449 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4451 Visual::Base visual = factory.CreateVisual(properties);
4453 // trigger creation through setting on stage
4454 DummyControl dummy = DummyControl::New(true);
4455 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4456 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4458 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4459 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4460 application.GetScene().Add(dummy);
4462 application.SendNotification();
4463 application.Render();
4465 // Wait for loading & rasterization
4466 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4468 application.SendNotification();
4469 application.Render();
4471 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4472 // Default corner radius policy is absolute.
4473 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4474 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4475 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4476 // Default borderline offset is 0.0.
4477 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4480 // animated vector image visual
4482 ToolkitTestApplication application;
4483 TestGraphicsController& graphics = application.GetGraphicsController();
4484 graphics.AddCustomUniforms(customUniforms);
4486 VisualFactory factory = VisualFactory::Get();
4487 Property::Map properties;
4488 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4489 float borderlineWidth = 13.0f;
4490 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4491 float borderlineOffset = 13.0f;
4493 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4494 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4495 properties["cornerRadius"] = cornerRadius;
4496 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4497 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4498 properties["borderlineColor"] = borderlineColor;
4499 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4501 Visual::Base visual = factory.CreateVisual(properties);
4503 // trigger creation through setting on stage
4504 DummyControl dummy = DummyControl::New(true);
4505 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4506 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4508 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4509 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4510 application.GetScene().Add(dummy);
4512 application.SendNotification();
4513 application.Render();
4515 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4517 application.SendNotification();
4518 application.Render();
4520 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4521 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4522 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4523 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4524 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4530 int UtcDaliVisualBorderlineBlendModeTest(void)
4532 ToolkitTestApplication application;
4533 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4534 VisualFactory factory = VisualFactory::Get();
4536 // Case 1 : Test which doesn't support borderline feature.
4538 tet_printf("Test Unsupported visual type\n");
4539 Property::Map propertyMap;
4540 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4541 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4542 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4543 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4545 DummyControl actor = DummyControl::New(true);
4546 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4547 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4548 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4549 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4550 application.GetScene().Add(actor);
4552 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4554 Renderer renderer = actor.GetRendererAt(0);
4556 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4557 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4558 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4560 application.GetScene().Remove(actor);
4563 // Case 2 : Test which support borderline feature.
4565 tet_printf("Test normal case\n");
4566 Property::Map propertyMap;
4567 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4568 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4569 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4570 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4572 DummyControl actor = DummyControl::New(true);
4573 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4574 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4575 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4576 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4577 application.GetScene().Add(actor);
4579 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4581 Renderer renderer = actor.GetRendererAt(0);
4583 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4584 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4585 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4587 application.GetScene().Remove(actor);
4590 // Case 3 : Test which animated borderline.
4592 tet_printf("Test borderline animate case\n");
4593 Property::Map propertyMap;
4594 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4595 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4596 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4598 DummyControl actor = DummyControl::New(true);
4599 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4600 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4601 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4602 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4603 application.GetScene().Add(actor);
4605 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4607 Renderer renderer = actor.GetRendererAt(0);
4609 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4610 // BlendMode is AUTO.
4611 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4613 Animation animation = Animation::New(0.1f);
4614 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4617 application.SendNotification();
4618 application.Render();
4619 application.Render(101u); // End of animation
4621 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4622 // BlendMode is ON_WITHOUT_CULL.
4623 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4625 Animation revanimation = Animation::New(0.1f);
4626 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4627 revanimation.Play();
4629 application.SendNotification();
4630 application.Render();
4631 application.Render(101u); // End of animation
4633 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4634 // BlendMode is still ON_WITHOUT_CULL.
4635 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4637 application.GetScene().Remove(actor);
4640 // Case 4 : Test which animated corner radius occur.
4642 tet_printf("Test borderline animate case\n");
4643 Property::Map propertyMap;
4644 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4645 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4646 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4647 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4649 DummyControl actor = DummyControl::New(true);
4650 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4651 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4652 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4653 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4654 application.GetScene().Add(actor);
4656 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4658 Renderer renderer = actor.GetRendererAt(0);
4660 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4661 // BlendMode is ON_WITHOUT_CULL.
4662 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4664 Animation animation = Animation::New(0.1f);
4665 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4668 application.SendNotification();
4669 application.Render();
4670 application.Render(101u); // End of animation
4672 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4673 // BlendMode is ON_WITHOUT_CULL.
4674 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4676 application.GetScene().Remove(actor);
4682 int UtcDaliVisualBorderlineColorAnimateTest(void)
4684 ToolkitTestApplication application;
4685 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4687 TestGraphicsController& graphics = application.GetGraphicsController();
4688 static std::vector<UniformData> customUniforms =
4690 UniformData("mixColor", Property::Type::VECTOR3),
4691 UniformData("cornerRadius", Property::Type::VECTOR4),
4692 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4693 UniformData("borderlineWidth", Property::Type::FLOAT),
4694 UniformData("borderlineColor", Property::Type::VECTOR4),
4695 UniformData("borderlineOffset", Property::Type::FLOAT),
4697 graphics.AddCustomUniforms(customUniforms);
4700 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4701 const float INITIAL_MIX_OPACITY(0.5f);
4702 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4703 const float INITIAL_ACTOR_OPACITY(1.0f);
4704 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4705 const float TARGET_MIX_OPACITY(0.8f);
4706 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4707 const float TARGET_ACTOR_OPACITY(0.5f);
4709 VisualFactory factory = VisualFactory::Get();
4710 Property::Map propertyMap;
4711 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4712 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4713 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4714 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4715 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4716 Visual::Base visual = factory.CreateVisual(propertyMap);
4718 DummyControl actor = DummyControl::New(true);
4719 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4720 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4721 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4722 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4723 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4724 application.GetScene().Add(actor);
4726 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4728 Animation animation = Animation::New(4.0f);
4729 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4730 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4731 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4732 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4735 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4737 application.SendNotification();
4738 application.Render(0);
4739 application.Render(2000u); // halfway point
4740 application.SendNotification();
4742 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4743 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4744 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4745 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4746 halfwayMixOpacity *= halfwayActorOpacity;
4747 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4748 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4749 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4750 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4752 application.Render(2001u); // go past end
4753 application.SendNotification(); // Trigger signals
4755 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4756 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4757 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4758 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4759 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4767 int UtcDaliColorVisualBlurRadius(void)
4769 ToolkitTestApplication application;
4770 tet_infoline("UtcDaliColorVisualBlurRadius");
4772 static std::vector<UniformData> customUniforms =
4774 UniformData("blurRadius", Property::Type::FLOAT),
4777 TestGraphicsController& graphics = application.GetGraphicsController();
4778 graphics.AddCustomUniforms(customUniforms);
4780 VisualFactory factory = VisualFactory::Get();
4781 Property::Map properties;
4782 float blurRadius = 20.0f;
4784 properties[Visual::Property::TYPE] = Visual::COLOR;
4785 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4786 properties["blurRadius"] = blurRadius;
4788 Visual::Base visual = factory.CreateVisual(properties);
4790 // trigger creation through setting on stage
4791 DummyControl dummy = DummyControl::New(true);
4792 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4793 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4795 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4796 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4797 application.GetScene().Add(dummy);
4799 application.SendNotification();
4800 application.Render();
4802 application.SendNotification();
4803 application.Render();
4805 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4810 int UtcDaliVisualGetType(void)
4812 ToolkitTestApplication application;
4813 tet_infoline("UtcDaliVisualGetType");
4815 VisualFactory factory = VisualFactory::Get();
4818 Property::Map properties;
4819 properties[Visual::Property::TYPE] = Visual::BORDER;
4820 Visual::Base visual = factory.CreateVisual(properties);
4822 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4826 Property::Map properties;
4827 properties[Visual::Property::TYPE] = Visual::COLOR;
4828 Visual::Base visual = factory.CreateVisual(properties);
4830 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4834 Property::Map properties;
4835 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4836 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4837 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4838 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4839 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4840 Property::Array stopColors;
4841 stopColors.PushBack(Color::RED);
4842 stopColors.PushBack(Color::GREEN);
4843 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4844 Visual::Base visual = factory.CreateVisual(properties);
4846 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4850 Property::Map properties;
4851 properties[Visual::Property::TYPE] = Visual::IMAGE;
4852 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4853 Visual::Base visual = factory.CreateVisual(properties);
4855 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4859 Property::Map properties;
4860 properties[Visual::Property::TYPE] = Visual::MESH;
4861 Visual::Base visual = factory.CreateVisual(properties);
4863 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4867 Property::Map properties;
4868 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4869 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4870 Visual::Base visual = factory.CreateVisual(properties);
4872 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4876 Property::Map properties;
4877 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4878 Visual::Base visual = factory.CreateVisual(properties);
4880 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4884 Property::Map properties;
4885 properties[Visual::Property::TYPE] = Visual::TEXT;
4886 Visual::Base visual = factory.CreateVisual(properties);
4888 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4892 Property::Map properties;
4893 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4894 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4895 Visual::Base visual = factory.CreateVisual(properties);
4897 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4901 Property::Map properties;
4902 properties[Visual::Property::TYPE] = Visual::SVG;
4903 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4904 Visual::Base visual = factory.CreateVisual(properties);
4906 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4910 Property::Map properties;
4911 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4912 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4913 Visual::Base visual = factory.CreateVisual(properties);
4915 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4919 Property::Map properties;
4920 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4921 Visual::Base visual = factory.CreateVisual(properties);
4923 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4927 Property::Map properties;
4928 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4929 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4930 Visual::Base visual = factory.CreateVisual(properties);
4932 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4936 Property::Map properties;
4937 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4938 Visual::Base visual = factory.CreateVisual(properties);
4940 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4946 int UtcDaliVisualGetVisualProperty01(void)
4948 ToolkitTestApplication application;
4949 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4951 static std::vector<UniformData> customUniforms =
4953 UniformData("mixColor", Property::Type::VECTOR3),
4954 UniformData("offset", Property::Type::VECTOR2),
4955 UniformData("size", Property::Type::VECTOR2),
4956 UniformData("cornerRadius", Property::Type::VECTOR4),
4957 UniformData("blurRadius", Property::Type::FLOAT),
4958 UniformData("borderlineWidth", Property::Type::FLOAT),
4959 UniformData("borderlineColor", Property::Type::VECTOR4),
4960 UniformData("borderlineOffset", Property::Type::FLOAT)};
4962 TestGraphicsController& graphics = application.GetGraphicsController();
4963 graphics.AddCustomUniforms(customUniforms);
4965 VisualFactory factory = VisualFactory::Get();
4966 Property::Map propertyMap;
4967 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4968 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4969 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4970 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4971 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4972 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4973 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4974 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4975 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4977 DummyControl dummyControl = DummyControl::New(true);
4978 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4979 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4980 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4981 application.GetScene().Add(dummyControl);
4983 application.SendNotification();
4984 application.Render();
4986 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4987 Vector2 targetOffset(0.05f, 0.05f);
4988 Vector2 targetSize(1.1f, 1.1f);
4989 float targetOpacity = 0.5f;
4990 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4991 float targetBlurRadius = 10.0f;
4992 float targetBorderlineWidth = 25.0f;
4993 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4994 float targetBorderlineOffset = -1.0f;
4996 Animation animation = Animation::New(1.0f);
4997 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4998 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4999 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5000 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5001 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5002 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5003 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5004 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5005 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5008 application.SendNotification();
5009 application.Render();
5010 application.Render(1001u); // End of animation
5012 Property::Map resultMap;
5013 colorVisual.CreatePropertyMap(resultMap);
5015 // Test property values: they should be updated
5016 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5017 DALI_TEST_CHECK(colorValue);
5018 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5020 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5021 Dali::Property::Map* transformMap = transformValue->GetMap();
5022 DALI_TEST_CHECK(transformMap);
5024 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5025 DALI_TEST_CHECK(offsetValue);
5026 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5028 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5029 DALI_TEST_CHECK(sizeValue);
5030 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5032 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5033 DALI_TEST_CHECK(cornerRadiusValue);
5034 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5036 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5037 DALI_TEST_CHECK(blurRadiusValue);
5038 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5040 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5041 DALI_TEST_CHECK(borderlineWidthValue);
5042 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5044 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5045 DALI_TEST_CHECK(borderlineColorValue);
5046 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5048 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5049 DALI_TEST_CHECK(borderlineOffsetValue);
5050 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5052 // Test uniform values
5053 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5054 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5055 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5056 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5057 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5058 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5059 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5060 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5062 // Test unregistered visual
5063 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5064 DALI_TEST_CHECK(!property3.object);
5065 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5070 int UtcDaliVisualGetVisualProperty02(void)
5072 ToolkitTestApplication application;
5073 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5075 static std::vector<UniformData> customUniforms =
5077 UniformData("mixColor", Property::Type::VECTOR3),
5078 UniformData("offset", Property::Type::VECTOR2),
5079 UniformData("size", Property::Type::VECTOR2),
5080 UniformData("cornerRadius", Property::Type::VECTOR4),
5081 UniformData("borderlineWidth", Property::Type::FLOAT),
5082 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5083 UniformData("borderlineOffset", Property::Type::FLOAT),
5084 UniformData("blurRadius", Property::Type::FLOAT),
5087 TestGraphicsController& graphics = application.GetGraphicsController();
5088 graphics.AddCustomUniforms(customUniforms);
5090 VisualFactory factory = VisualFactory::Get();
5091 Property::Map propertyMap;
5092 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5093 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5095 DummyControl dummyControl = DummyControl::New(true);
5096 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5097 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5098 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5099 application.GetScene().Add(dummyControl);
5101 application.SendNotification();
5102 application.Render();
5104 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5105 Vector2 targetOffset(0.05f, 0.05f);
5106 Vector2 targetSize(1.1f, 1.1f);
5107 float targetOpacity = 0.5f;
5108 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5109 float targetBorderlineWidth = 77.7f;
5110 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5111 float targetBorderlineOffset = 1.0f;
5112 float targetBlurRadius = 10.0f;
5114 // Should work when the properties are not set before
5115 Animation animation = Animation::New(1.0f);
5116 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5117 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5118 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5119 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5120 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5121 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5122 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5123 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5124 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5127 application.SendNotification();
5128 application.Render();
5129 application.Render(1001u); // End of animation
5131 Property::Map resultMap;
5132 colorVisual.CreatePropertyMap(resultMap);
5134 // Test property values: they should be updated
5135 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5136 DALI_TEST_CHECK(colorValue);
5137 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5139 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5140 Dali::Property::Map* transformMap = transformValue->GetMap();
5141 DALI_TEST_CHECK(transformMap);
5143 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5144 DALI_TEST_CHECK(offsetValue);
5145 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5147 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5148 DALI_TEST_CHECK(sizeValue);
5149 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5151 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5152 DALI_TEST_CHECK(cornerRadiusValue);
5153 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5155 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5156 DALI_TEST_CHECK(borderlineWidthValue);
5157 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5159 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5160 DALI_TEST_CHECK(borderlineColorValue);
5161 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5163 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5164 DALI_TEST_CHECK(borderlineOffsetValue);
5165 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5167 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5168 DALI_TEST_CHECK(blurRadiusValue);
5169 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5171 // Test uniform values
5172 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5173 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5174 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5175 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5176 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5181 int UtcDaliVisualGetVisualProperty03(void)
5183 ToolkitTestApplication application;
5184 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5186 static std::vector<UniformData> customUniforms =
5188 UniformData("cornerRadius", Property::Type::VECTOR4),
5189 UniformData("borderlineWidth", Property::Type::FLOAT),
5190 UniformData("borderlineColor", Property::Type::VECTOR4),
5191 UniformData("borderlineOffset", Property::Type::FLOAT),
5194 TestGraphicsController& graphics = application.GetGraphicsController();
5195 graphics.AddCustomUniforms(customUniforms);
5197 VisualFactory factory = VisualFactory::Get();
5198 Property::Map propertyMap;
5199 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5200 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5202 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5204 DummyControl dummyControl = DummyControl::New(true);
5205 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5206 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5207 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5208 application.GetScene().Add(dummyControl);
5210 // Wait for image loading
5211 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5213 application.SendNotification();
5214 application.Render();
5216 float targetOpacity = 0.5f;
5217 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5218 float targetBorderlineWidth = 10.0f;
5219 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5220 float targetBorderlineOffset = -1.5f;
5222 Animation animation = Animation::New(1.0f);
5223 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5224 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5225 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5226 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5227 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5230 application.SendNotification();
5231 application.Render();
5232 application.Render(1001u); // End of animation
5234 Property::Map resultMap;
5235 imageVisual.CreatePropertyMap(resultMap);
5237 // Test property values: they should be updated
5238 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5239 DALI_TEST_CHECK(colorValue);
5240 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5242 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5243 DALI_TEST_CHECK(cornerRadiusValue);
5244 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5246 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5247 DALI_TEST_CHECK(borderlineWidthValue);
5248 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5250 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5251 DALI_TEST_CHECK(borderlineColorValue);
5252 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5254 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5255 DALI_TEST_CHECK(borderlineOffsetValue);
5256 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5258 // Test uniform value
5259 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5260 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5261 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5262 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5267 int UtcDaliVisualGetVisualProperty04(void)
5269 ToolkitTestApplication application;
5270 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5272 static std::vector<UniformData> customUniforms =
5274 UniformData("cornerRadius", Property::Type::VECTOR4),
5277 TestGraphicsController& graphics = application.GetGraphicsController();
5278 graphics.AddCustomUniforms(customUniforms);
5280 Vector2 start(-1.f, -1.f);
5281 Vector2 end(1.f, 1.f);
5282 Property::Array stopColors;
5283 stopColors.PushBack(Color::RED);
5284 stopColors.PushBack(Color::GREEN);
5286 VisualFactory factory = VisualFactory::Get();
5287 Property::Map propertyMap;
5288 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5289 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5290 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5291 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5292 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5293 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5294 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5296 DummyControl dummyControl = DummyControl::New(true);
5297 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5298 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5299 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5300 application.GetScene().Add(dummyControl);
5302 application.SendNotification();
5303 application.Render();
5305 float targetOpacity = 0.5f;
5306 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5308 Animation animation = Animation::New(1.0f);
5309 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5310 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5313 application.SendNotification();
5314 application.Render();
5315 application.Render(1001u); // End of animation
5317 Property::Map resultMap;
5318 gradientVisual.CreatePropertyMap(resultMap);
5320 // Test property values: they should be updated
5321 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5322 DALI_TEST_CHECK(colorValue);
5323 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5325 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5326 DALI_TEST_CHECK(cornerRadiusValue);
5327 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5329 // Test uniform value
5330 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5335 int UtcDaliVisualGetVisualProperty05(void)
5337 ToolkitTestApplication application;
5338 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5340 static std::vector<UniformData> customUniforms =
5342 UniformData("cornerRadius", Property::Type::VECTOR4),
5343 UniformData("borderlineWidth", Property::Type::FLOAT),
5344 UniformData("borderlineColor", Property::Type::VECTOR4),
5345 UniformData("borderlineOffset", Property::Type::FLOAT),
5348 TestGraphicsController& graphics = application.GetGraphicsController();
5349 graphics.AddCustomUniforms(customUniforms);
5351 VisualFactory factory = VisualFactory::Get();
5352 Property::Map propertyMap;
5353 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5354 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5356 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5358 DummyControl dummyControl = DummyControl::New(true);
5359 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5360 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5361 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5362 application.GetScene().Add(dummyControl);
5364 application.SendNotification();
5365 application.Render();
5367 // Wait for loading & rasterization
5368 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5370 application.SendNotification();
5371 application.Render();
5373 float targetOpacity = 0.5f;
5374 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5375 float targetBorderlineWidth = 10.0f;
5376 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5377 float targetBorderlineOffset = -1.5f;
5379 Animation animation = Animation::New(1.0f);
5380 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5381 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5382 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5383 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5384 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5387 application.SendNotification();
5388 application.Render();
5389 application.Render(1001u); // End of animation
5391 Property::Map resultMap;
5392 svgVisual.CreatePropertyMap(resultMap);
5394 // Test property values: they should be updated
5395 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5396 DALI_TEST_CHECK(colorValue);
5397 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5399 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5400 DALI_TEST_CHECK(cornerRadiusValue);
5401 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5403 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5404 DALI_TEST_CHECK(borderlineWidthValue);
5405 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5407 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5408 DALI_TEST_CHECK(borderlineColorValue);
5409 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5411 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5412 DALI_TEST_CHECK(borderlineOffsetValue);
5413 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5415 // Currently test with multiple program doesn't work well. will fix another day
5416 // Test uniform value
5417 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5418 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5419 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5420 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5425 int UtcDaliVisualGetVisualProperty06(void)
5427 ToolkitTestApplication application;
5428 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5430 static std::vector<UniformData> customUniforms =
5432 UniformData("cornerRadius", Property::Type::VECTOR4),
5433 UniformData("borderlineWidth", Property::Type::FLOAT),
5434 UniformData("borderlineColor", Property::Type::VECTOR4),
5435 UniformData("borderlineOffset", Property::Type::FLOAT),
5438 TestGraphicsController& graphics = application.GetGraphicsController();
5439 graphics.AddCustomUniforms(customUniforms);
5441 VisualFactory factory = VisualFactory::Get();
5442 Property::Map propertyMap;
5443 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5444 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5446 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5448 DummyControl dummyControl = DummyControl::New(true);
5449 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5450 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5451 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5452 application.GetScene().Add(dummyControl);
5454 application.SendNotification();
5455 application.Render();
5457 // Wait for image loading
5458 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5460 application.SendNotification();
5461 application.Render();
5463 float targetOpacity = 0.5f;
5464 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5465 float targetBorderlineWidth = 10.0f;
5466 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5467 float targetBorderlineOffset = -1.5f;
5469 Animation animation = Animation::New(1.0f);
5470 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5471 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5472 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5473 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5474 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5477 application.SendNotification();
5478 application.Render();
5479 application.Render(1001u); // End of animation
5481 Property::Map resultMap;
5482 animatedImageVisual.CreatePropertyMap(resultMap);
5484 // Test property values: they should be updated
5485 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5486 DALI_TEST_CHECK(colorValue);
5487 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5489 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5490 DALI_TEST_CHECK(cornerRadiusValue);
5491 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5493 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5494 DALI_TEST_CHECK(borderlineWidthValue);
5495 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5497 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5498 DALI_TEST_CHECK(borderlineColorValue);
5499 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5501 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5502 DALI_TEST_CHECK(borderlineOffsetValue);
5503 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5505 // Currently test with multiple program doesn't work well. will fix another day
5506 // Test uniform value
5507 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5508 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5509 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5510 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5515 int UtcDaliVisualGetVisualProperty07(void)
5517 ToolkitTestApplication application;
5518 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5520 static std::vector<UniformData> customUniforms =
5522 UniformData("cornerRadius", Property::Type::VECTOR4),
5523 UniformData("borderlineWidth", Property::Type::FLOAT),
5524 UniformData("borderlineColor", Property::Type::VECTOR4),
5525 UniformData("borderlineOffset", Property::Type::FLOAT),
5528 TestGraphicsController& graphics = application.GetGraphicsController();
5529 graphics.AddCustomUniforms(customUniforms);
5531 VisualFactory factory = VisualFactory::Get();
5532 Property::Map propertyMap;
5533 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5534 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5536 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5538 DummyControl dummyControl = DummyControl::New(true);
5539 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5540 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5541 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5542 application.GetScene().Add(dummyControl);
5544 application.SendNotification();
5545 application.Render();
5547 // Wait for image loading
5548 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5550 application.SendNotification();
5551 application.Render();
5553 float targetOpacity = 0.5f;
5554 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5555 float targetBorderlineWidth = 10.0f;
5556 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5557 float targetBorderlineOffset = -1.5f;
5559 Animation animation = Animation::New(1.0f);
5560 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5561 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5562 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5563 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5564 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5567 application.SendNotification();
5568 application.Render();
5569 application.Render(1001u); // End of animation
5571 Property::Map resultMap;
5572 animatedVectorVisual.CreatePropertyMap(resultMap);
5574 // Test property values: they should be updated
5575 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5576 DALI_TEST_CHECK(colorValue);
5577 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5579 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5580 DALI_TEST_CHECK(cornerRadiusValue);
5581 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5583 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5584 DALI_TEST_CHECK(borderlineWidthValue);
5585 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5587 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5588 DALI_TEST_CHECK(borderlineColorValue);
5589 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5591 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5592 DALI_TEST_CHECK(borderlineOffsetValue);
5593 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5595 // Currently test with multiple program doesn't work well. will fix another day
5596 // Test uniform value
5597 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5598 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5599 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5600 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5605 int UtcDaliVisualUpdateProperty(void)
5607 ToolkitTestApplication application;
5608 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5610 VisualFactory factory = VisualFactory::Get();
5611 Property::Map propertyMap;
5612 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5613 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5614 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5615 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5617 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5619 DummyControl dummyControl = DummyControl::New(true);
5620 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5621 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5622 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5623 application.GetScene().Add(dummyControl);
5625 application.SendNotification();
5626 application.Render();
5628 // Wait for image loading
5629 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5631 application.SendNotification();
5632 application.Render();
5634 Property::Map originalMap;
5635 imageVisual.CreatePropertyMap(originalMap);
5637 float targetOpacity = 0.5f;
5638 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5639 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5640 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5642 Property::Map targetPropertyMap;
5643 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5644 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5645 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5646 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5647 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5649 // Update Properties
5650 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5652 Property::Map resultMap;
5653 imageVisual.CreatePropertyMap(resultMap);
5655 // Test property values: they should be updated
5656 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5657 DALI_TEST_CHECK(colorValue);
5658 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5660 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5661 DALI_TEST_CHECK(urlValue);
5662 // NOTE : ImageVisual URL must NOT changed.
5663 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5665 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5666 DALI_TEST_CHECK(preMultipliedValue);
5667 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5669 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5670 DALI_TEST_CHECK(visualFittingModeValue);
5671 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5676 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5678 ToolkitTestApplication application;
5679 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5681 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5683 VisualFactory factory = VisualFactory::Get();
5684 Property::Map propertyMap;
5686 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5687 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5689 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5691 DummyControl dummyControl = DummyControl::New(true);
5692 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5693 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5694 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5695 application.GetScene().Add(dummyControl);
5697 application.SendNotification();
5698 application.Render();
5700 // Wait for image loading
5701 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5703 application.SendNotification();
5704 application.Render();
5706 TestShaderCodeContainSubstrings(
5709 {"#define IS_REQUIRED_BORDERLINE", false},
5710 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5715 callStack.Enable(true);
5717 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5719 Property::Map targetPropertyMap;
5720 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5721 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5723 // Update Properties with CornerRadius
5724 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5726 Property::Map resultMap;
5727 imageVisual.CreatePropertyMap(resultMap);
5729 // Test property values: they should be updated
5730 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5731 DALI_TEST_CHECK(cornerRadiusValue);
5732 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5734 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5735 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5736 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5738 TestShaderCodeContainSubstrings(
5741 {"#define IS_REQUIRED_BORDERLINE", false},
5742 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
5746 // Send shader compile signal
5747 application.SendNotification();
5748 application.Render();
5750 callStack.Enable(false);
5752 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5754 callStack.Enable(true);
5756 float targetBorderlineWidth = 10.0f;
5757 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5758 float targetBorderlineOffset = -0.3f;
5760 Property::Map targetPropertyMap2;
5761 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5762 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5763 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5764 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5765 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5767 // Update Properties with Borderline
5768 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5770 Property::Map resultMap2;
5771 imageVisual.CreatePropertyMap(resultMap2);
5773 // Test property values: they should be updated
5774 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5775 DALI_TEST_CHECK(cornerRadiusValue);
5776 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5778 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5779 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5780 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5782 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5783 DALI_TEST_CHECK(borderlineWidthValue);
5784 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5786 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5787 DALI_TEST_CHECK(borderlineColorValue);
5788 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5790 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5791 DALI_TEST_CHECK(borderlineOffsetValue);
5792 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5794 TestShaderCodeContainSubstrings(
5797 {"#define IS_REQUIRED_BORDERLINE", true},
5798 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
5802 // Send shader compile signal
5803 application.SendNotification();
5804 application.Render();
5806 callStack.Enable(false);
5808 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5810 callStack.Enable(true);
5812 Property::Map targetPropertyMap3;
5813 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5814 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5815 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5816 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5817 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5819 // Update Properties into zero
5820 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5822 Property::Map resultMap3;
5823 imageVisual.CreatePropertyMap(resultMap3);
5825 // Test property values: they should be updated
5826 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5827 DALI_TEST_CHECK(cornerRadiusValue);
5828 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5830 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5831 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5832 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5834 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5835 DALI_TEST_CHECK(borderlineWidthValue);
5836 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5838 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5839 DALI_TEST_CHECK(borderlineColorValue);
5840 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5842 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5843 DALI_TEST_CHECK(borderlineOffsetValue);
5844 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5846 TestShaderCodeContainSubstrings(
5849 {"#define IS_REQUIRED_BORDERLINE", true}, // Note : mAlwaysUsingBorderline is true.
5850 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
5854 // Send shader compile signal
5855 application.SendNotification();
5856 application.Render();
5858 callStack.Enable(false);
5859 // Shader not changed
5860 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5865 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5867 ToolkitTestApplication application;
5868 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5870 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5872 VisualFactory factory = VisualFactory::Get();
5873 Property::Map propertyMap;
5875 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5876 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5878 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5880 DummyControl dummyControl = DummyControl::New(true);
5881 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5882 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5883 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5884 application.GetScene().Add(dummyControl);
5886 application.SendNotification();
5887 application.Render();
5889 // Wait for image loading
5890 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5892 application.SendNotification();
5893 application.Render();
5895 TestShaderCodeContainSubstrings(
5898 {"#define IS_REQUIRED_BORDERLINE", false},
5899 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5903 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5905 Property::Map targetPropertyMap;
5906 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5909 callStack.Enable(true);
5911 // Update Properties with CornerRadius
5912 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5914 Property::Map resultMap;
5915 imageVisual.CreatePropertyMap(resultMap);
5917 // Test property values: they should be updated
5918 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5919 DALI_TEST_CHECK(cornerRadiusValue);
5920 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5922 TestShaderCodeContainSubstrings(
5925 {"#define IS_REQUIRED_BORDERLINE", false},
5926 {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
5930 // Send shader compile signal
5931 application.SendNotification();
5932 application.Render();
5934 callStack.Enable(false);
5936 // Shader doesn't changed
5937 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5939 callStack.Enable(true);
5941 float targetBorderlineWidth = 0.0f;
5942 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5943 float targetBorderlineOffset = -1.0f;
5945 Property::Map targetPropertyMap2;
5946 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5947 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5948 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5950 // Update Properties with Borderline
5951 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5953 Property::Map resultMap2;
5954 imageVisual.CreatePropertyMap(resultMap2);
5956 // Test property values: they should be updated
5957 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5958 DALI_TEST_CHECK(borderlineWidthValue);
5959 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5961 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5962 DALI_TEST_CHECK(borderlineColorValue);
5963 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5965 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5966 DALI_TEST_CHECK(borderlineOffsetValue);
5967 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5969 TestShaderCodeContainSubstrings(
5972 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
5973 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5977 // Send shader compile signal
5978 application.SendNotification();
5979 application.Render();
5981 callStack.Enable(false);
5983 // Shader doesn't changed
5984 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5989 int UtcDaliVisualUpdatePropertyChangeShader03(void)
5991 ToolkitTestApplication application;
5992 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
5994 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5996 VisualFactory factory = VisualFactory::Get();
5997 Property::Map propertyMap;
5999 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6000 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6002 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6004 DummyControl dummyControl = DummyControl::New(true);
6005 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6006 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6007 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6008 application.GetScene().Add(dummyControl);
6010 application.SendNotification();
6011 application.Render();
6013 application.SendNotification();
6014 application.Render();
6016 TestShaderCodeContainSubstrings(
6019 {"#define IS_REQUIRED_BLUR", false},
6020 {"#define IS_REQUIRED_BORDERLINE", false},
6021 {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6025 float targetBlurRadius = 15.0f;
6026 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6028 Property::Map targetPropertyMap;
6029 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6030 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6031 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6034 callStack.Enable(true);
6036 // Update Properties with CornerRadius
6037 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6039 Property::Map resultMap;
6040 imageVisual.CreatePropertyMap(resultMap);
6042 // Test property values: they should be updated
6043 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6044 DALI_TEST_CHECK(blurRadiusValue);
6045 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6047 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6048 DALI_TEST_CHECK(cornerRadiusValue);
6049 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6051 TestShaderCodeContainSubstrings(
6054 {"#define IS_REQUIRED_BLUR", true},
6055 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6056 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6060 // Send shader compile signal
6061 application.SendNotification();
6062 application.Render();
6064 callStack.Enable(false);
6067 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6069 callStack.Enable(true);
6071 Property::Map targetPropertyMap2;
6072 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6073 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6074 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6076 // Update Properties with CornerRadius
6077 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6079 Property::Map resultMap2;
6080 imageVisual.CreatePropertyMap(resultMap2);
6082 // Test property values: they should be updated
6083 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6084 DALI_TEST_CHECK(blurRadiusValue);
6085 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6087 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6088 DALI_TEST_CHECK(cornerRadiusValue);
6089 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6091 TestShaderCodeContainSubstrings(
6094 {"#define IS_REQUIRED_BLUR", true}, // Note : mAlwaysUsingBlurRadius is true.
6095 {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6096 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6100 // Send shader compile signal
6101 application.SendNotification();
6102 application.Render();
6104 callStack.Enable(false);
6106 // Shader not changed
6107 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6112 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6114 ToolkitTestApplication application;
6115 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6117 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6119 VisualFactory factory = VisualFactory::Get();
6120 Property::Map propertyMap;
6122 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6123 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6124 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6126 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6128 DummyControl dummyControl = DummyControl::New(true);
6129 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6130 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6131 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6132 application.GetScene().Add(dummyControl);
6134 application.SendNotification();
6135 application.Render();
6137 // Wait for image loading
6138 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6140 application.SendNotification();
6141 application.Render();
6143 TestShaderCodeContainSubstrings(
6146 {"#define IS_REQUIRED_BORDERLINE", false},
6147 {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6152 callStack.Enable(true);
6154 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6156 Animation animation = Animation::New(1.0f);
6157 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6160 application.SendNotification();
6161 application.Render();
6162 application.Render(1001u); // End of animation
6164 TestShaderCodeContainSubstrings(
6167 {"#define IS_REQUIRED_BORDERLINE", false},
6168 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6172 callStack.Enable(false);
6173 // Shader not changed
6174 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6176 callStack.Enable(true);
6178 float targetBorderlineWidth = 10.0f;
6179 Property::Map targetPropertyMap;
6180 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6182 // Update Properties with CornerRadius
6183 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6185 Property::Map resultMap;
6186 imageVisual.CreatePropertyMap(resultMap);
6188 // Test property values: they should be updated
6189 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6190 DALI_TEST_CHECK(cornerRadiusValue);
6191 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6193 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6194 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6195 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6197 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6198 DALI_TEST_CHECK(borderlineWidthValue);
6199 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6201 TestShaderCodeContainSubstrings(
6204 {"#define IS_REQUIRED_BORDERLINE", true},
6205 {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6209 // Send shader compile signal
6210 application.SendNotification();
6211 application.Render();
6213 callStack.Enable(false);
6215 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));