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());
146 void dali_visual_startup(void)
148 test_return_value = TET_UNDEF;
151 void dali_visual_cleanup(void)
153 test_return_value = TET_PASS;
156 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
159 visual.CreatePropertyMap(map);
160 Property::Value* value = map.Find(mixColorIndex);
161 DALI_TEST_CHECK(value);
163 DALI_TEST_CHECK(value->Get(mixColor1));
164 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
166 value = map.Find(Visual::Property::MIX_COLOR);
167 DALI_TEST_CHECK(value);
169 DALI_TEST_CHECK(value->Get(mixColor2));
170 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
172 value = map.Find(Visual::Property::OPACITY);
173 DALI_TEST_CHECK(value);
175 DALI_TEST_CHECK(value->Get(opacity));
176 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
179 int UtcDaliVisualCopyAndAssignment(void)
181 ToolkitTestApplication application;
182 tet_infoline("UtcDaliVisualCopyAndAssignment");
184 VisualFactory factory = VisualFactory::Get();
185 Property::Map propertyMap;
186 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
187 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
188 Visual::Base visual = factory.CreateVisual(propertyMap);
190 Visual::Base visualCopy(visual);
191 DALI_TEST_CHECK(visual == visualCopy);
193 Visual::Base emptyVisual;
194 Visual::Base emptyVisualCopy(emptyVisual);
195 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
197 Visual::Base visualEquals;
198 visualEquals = visual;
199 DALI_TEST_CHECK(visual == visualEquals);
201 Visual::Base emptyVisualEquals;
202 emptyVisualEquals = emptyVisual;
203 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
207 DALI_TEST_CHECK(visual = visualCopy);
212 int UtcDaliVisualSetName01(void)
214 ToolkitTestApplication application;
215 tet_infoline("UtcDaliVisualSetName");
217 VisualFactory factory = VisualFactory::Get();
218 Property::Map propertyMap;
219 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
220 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
221 Visual::Base visual = factory.CreateVisual(propertyMap);
223 const char* visualName = "backgroundVisual";
224 visual.SetName(visualName);
226 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
231 int UtcDaliVisualSetGetDepthIndex(void)
233 ToolkitTestApplication application;
234 tet_infoline("UtcDaliVisualSetDepthIndex");
236 VisualFactory factory = VisualFactory::Get();
237 Property::Map propertyMap;
238 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
239 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
240 Visual::Base visual = factory.CreateVisual(propertyMap);
242 visual.SetDepthIndex(1);
244 DummyControl dummyControl = DummyControl::New(true);
245 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
246 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
248 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
249 application.GetScene().Add(dummyControl);
251 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
252 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
253 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
255 visual.SetDepthIndex(-1);
256 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
257 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
258 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
263 int UtcDaliVisualSize(void)
265 ToolkitTestApplication application;
266 tet_infoline("UtcDaliVisualSize");
268 VisualFactory factory = VisualFactory::Get();
269 Vector2 controlSize(20.f, 30.f);
273 Dali::Property::Map map;
274 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
275 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
277 Visual::Base colorVisual = factory.CreateVisual(map);
278 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
280 colorVisual.GetNaturalSize(naturalSize);
281 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
285 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
286 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
287 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
288 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
289 Visual::Base imageVisual = factory.CreateVisual(map);
290 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
292 imageVisual.GetNaturalSize(naturalSize);
293 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
295 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
298 float borderSize = 5.f;
300 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
301 map[BorderVisual::Property::COLOR] = Color::RED;
302 map[BorderVisual::Property::SIZE] = borderSize;
303 Visual::Base borderVisual = factory.CreateVisual(map);
304 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
305 borderVisual.GetNaturalSize(naturalSize);
306 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
308 // gradient gradientVisual
309 Property::Map propertyMap;
310 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
311 Vector2 start(-1.f, -1.f);
312 Vector2 end(1.f, 1.f);
313 propertyMap.Insert("mixColor", Color::MAGENTA);
314 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
315 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
316 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
317 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
318 Property::Array stopColors;
319 stopColors.PushBack(Color::RED);
320 stopColors.PushBack(Color::GREEN);
321 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
322 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
323 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
324 gradientVisual.GetNaturalSize(naturalSize);
325 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
327 // animated gradient visual
328 Vector2 animated_gradient_visual_size(10.f, 10.f);
330 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
331 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
332 animatedGradientVisual.GetNaturalSize(naturalSize);
333 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
334 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
337 Visual::Base svgVisual = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
338 svgVisual.GetNaturalSize(naturalSize);
340 // <svg width="100" height="100">
341 // <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
343 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION);
345 // svg visual with a size
346 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(200, 200));
347 svgVisual2.GetNaturalSize(naturalSize);
348 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION); // Natural size should still be 100, 100
352 // Load some fonts to get the same metrics on different platforms.
353 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
354 fontClient.SetDpi(96u, 96u);
356 char* pathNamePtr = get_current_dir_name();
357 const std::string pathName(pathNamePtr);
360 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
362 // Create a TextVisual with a font size of 12 first
364 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
365 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
366 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
367 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
369 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
370 Vector2 smallTextVisualNaturalSize;
371 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
373 // Then create a TextVisual with a font size of 20
374 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
375 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
376 Vector2 largeTextVisualNaturalSize;
377 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
379 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
380 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
381 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
383 // The height returned for a particular width should also be greater for the large text visual
384 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
386 //AnimatedImageVisual
387 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
388 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
389 animatedImageVisual.GetNaturalSize(naturalSize);
390 // TEST_GIF_FILE: anim.gif
391 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
392 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
397 int UtcDaliVisualSetOnOffScene(void)
399 ToolkitTestApplication application;
400 tet_infoline("UtcDaliVisualSetOnOffScene");
402 VisualFactory factory = VisualFactory::Get();
403 Property::Map propertyMap;
404 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
405 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
406 Visual::Base visual = factory.CreateVisual(propertyMap);
408 DummyControl actor = DummyControl::New(true);
409 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
410 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
412 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
414 application.SendNotification();
415 application.Render(0);
416 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
418 application.GetScene().Add(actor);
420 application.SendNotification();
421 application.Render(0);
422 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
424 application.GetScene().Remove(actor);
426 application.SendNotification();
427 application.Render(0);
428 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
433 int UtcDaliVisualSetOnOffScene2(void)
435 ToolkitTestApplication application;
436 tet_infoline("UtcDaliVisualSetOnOffScene2");
438 VisualFactory factory = VisualFactory::Get();
439 Property::Map propertyMap;
440 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
441 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
442 Visual::Base visual = factory.CreateVisual(propertyMap);
444 DummyControl actor = DummyControl::New(true);
445 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
446 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
448 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
450 application.SendNotification();
451 application.Render(0);
452 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
455 application.GetScene().Add(actor);
457 application.SendNotification();
458 application.Render(0);
459 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
460 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
461 Renderer renderer = actor.GetRendererAt(0);
462 auto textures = renderer.GetTextures();
463 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
465 application.GetScene().Remove(actor);
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);
476 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
477 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
478 renderer = actor.GetRendererAt(0);
479 textures = renderer.GetTextures();
480 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
482 application.GetScene().Remove(actor);
484 application.SendNotification();
485 application.Render(0);
486 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
491 int UtcDaliVisualGetPropertyMap1(void)
493 ToolkitTestApplication application;
494 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
496 VisualFactory factory = VisualFactory::Get();
497 Property::Map propertyMap;
498 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
499 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
500 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
501 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
502 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
503 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
504 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
505 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
506 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
508 Property::Map resultMap;
509 colorVisual.CreatePropertyMap(resultMap);
511 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
512 DALI_TEST_CHECK(typeValue);
513 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
515 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
516 DALI_TEST_CHECK(colorValue);
517 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
519 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
520 DALI_TEST_CHECK(cornerRadiusValue);
521 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
523 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
524 DALI_TEST_CHECK(cornerRadiusPolicyValue);
525 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
527 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
528 DALI_TEST_CHECK(borderlineWidthValue);
529 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
531 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
532 DALI_TEST_CHECK(borderlineColorValue);
533 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
535 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
536 DALI_TEST_CHECK(borderlineOffsetValue);
537 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
539 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
540 DALI_TEST_CHECK(blurRadiusValue);
541 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
543 // change the blend color
544 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
545 colorVisual = factory.CreateVisual(propertyMap);
546 colorVisual.CreatePropertyMap(resultMap);
548 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
549 DALI_TEST_CHECK(colorValue);
550 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
553 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
555 colorVisual = factory.CreateVisual(propertyMap);
556 colorVisual.CreatePropertyMap(resultMap);
558 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
559 DALI_TEST_CHECK(blurRadiusValue);
560 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
565 int UtcDaliVisualGetPropertyMap2(void)
567 ToolkitTestApplication application;
568 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
570 VisualFactory factory = VisualFactory::Get();
571 Property::Map propertyMap;
572 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
573 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
574 propertyMap.Insert("borderColor", Color::BLUE);
575 propertyMap.Insert("borderSize", 5.f);
576 propertyMap.Insert("antiAliasing", true);
577 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
579 Property::Map resultMap;
580 borderVisual.CreatePropertyMap(resultMap);
582 // check the property values from the returned map from visual
583 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
584 DALI_TEST_CHECK(typeValue);
585 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
587 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
588 DALI_TEST_CHECK(colorValue);
589 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
591 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
592 DALI_TEST_CHECK(sizeValue);
593 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
595 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
596 DALI_TEST_CHECK(AAValue);
597 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
599 Property::Map propertyMap1;
600 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
601 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
602 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
603 borderVisual = factory.CreateVisual(propertyMap1);
604 borderVisual.CreatePropertyMap(resultMap);
606 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
607 DALI_TEST_CHECK(typeValue);
608 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
610 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
611 DALI_TEST_CHECK(colorValue);
612 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
614 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
615 DALI_TEST_CHECK(sizeValue);
616 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
621 int UtcDaliVisualGetPropertyMap2N(void)
623 ToolkitTestApplication application;
624 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
626 VisualFactory factory = VisualFactory::Get();
627 Property::Map propertyMap;
628 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
629 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
631 tet_infoline("Test that the visual is created, with a default renderer");
632 DALI_TEST_CHECK(borderVisual);
634 DummyControl dummyControl = DummyControl::New(true);
635 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
636 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
637 application.GetScene().Add(dummyControl);
639 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
644 int UtcDaliVisualGetPropertyMap3(void)
646 ToolkitTestApplication application;
647 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
649 VisualFactory factory = VisualFactory::Get();
650 DALI_TEST_CHECK(factory);
652 Property::Map propertyMap;
653 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
655 Vector2 start(-1.f, -1.f);
656 Vector2 end(1.f, 1.f);
657 propertyMap.Insert("startPosition", start);
658 propertyMap.Insert("endPosition", end);
659 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
661 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
663 Property::Array stopColors;
664 stopColors.PushBack(Color::RED);
665 stopColors.PushBack(Color::GREEN);
666 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
668 float borderlineWidth = 4.0f;
669 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
670 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
671 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
673 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
675 Property::Map resultMap;
676 gradientVisual.CreatePropertyMap(resultMap);
678 // check the property values from the returned map from visual
679 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
680 DALI_TEST_CHECK(value);
681 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
683 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
684 DALI_TEST_CHECK(value);
685 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
687 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
688 DALI_TEST_CHECK(value);
689 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
691 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
692 DALI_TEST_CHECK(value);
693 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
695 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
696 DALI_TEST_CHECK(value);
697 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
699 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
700 DALI_TEST_CHECK(value);
701 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
703 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
704 DALI_TEST_CHECK(value);
705 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
707 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
708 DALI_TEST_CHECK(value);
709 Property::Array* offsetArray = value->GetArray();
710 DALI_TEST_CHECK(offsetArray->Count() == 2);
711 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
712 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
714 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
715 DALI_TEST_CHECK(value);
716 Property::Array* colorArray = value->GetArray();
717 DALI_TEST_CHECK(colorArray->Count() == 2);
718 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
719 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
724 int UtcDaliVisualGetPropertyMap4(void)
726 ToolkitTestApplication application;
727 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
729 VisualFactory factory = VisualFactory::Get();
730 DALI_TEST_CHECK(factory);
732 Property::Map propertyMap;
733 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
735 Vector2 center(100.f, 100.f);
736 float radius = 100.f;
737 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
738 propertyMap.Insert(GradientVisual::Property::CENTER, center);
739 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
740 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
742 Property::Array stopColors;
743 stopColors.PushBack(Color::RED);
744 stopColors.PushBack(Color::BLACK);
745 stopColors.PushBack(Color::GREEN);
746 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
748 float borderlineWidth = 8.0f;
749 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
750 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
751 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
753 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
754 DALI_TEST_CHECK(gradientVisual);
756 Property::Map resultMap;
757 gradientVisual.CreatePropertyMap(resultMap);
759 // check the property values from the returned map from visual
760 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
761 DALI_TEST_CHECK(value);
762 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
764 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
765 DALI_TEST_CHECK(value);
766 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
768 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
769 DALI_TEST_CHECK(value);
770 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
772 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
773 DALI_TEST_CHECK(value);
774 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
776 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
777 DALI_TEST_CHECK(value);
778 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
780 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
781 DALI_TEST_CHECK(value);
782 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
784 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
785 DALI_TEST_CHECK(value);
786 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
788 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
789 DALI_TEST_CHECK(value);
790 Property::Array* offsetArray = value->GetArray();
791 DALI_TEST_CHECK(offsetArray->Count() == 3);
792 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
793 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
794 // any stop value will be clamped to [0.0, 1.0];
795 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
797 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
798 DALI_TEST_CHECK(value);
799 Property::Array* colorArray = value->GetArray();
800 DALI_TEST_CHECK(colorArray->Count() == 3);
801 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
802 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
803 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
808 int UtcDaliVisualGetPropertyMap5(void)
810 ToolkitTestApplication application;
811 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
813 VisualFactory factory = VisualFactory::Get();
814 Property::Map propertyMap;
815 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
816 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
817 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
818 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
819 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
820 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
821 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
822 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
823 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
824 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
825 propertyMap.Insert("synchronousLoading", true);
827 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
828 DALI_TEST_CHECK(imageVisual);
830 Property::Map resultMap;
831 imageVisual.CreatePropertyMap(resultMap);
833 // check the property values from the returned map from visual
834 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
835 DALI_TEST_CHECK(value);
836 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
838 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
839 DALI_TEST_CHECK(value);
840 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
842 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
843 DALI_TEST_CHECK(value);
844 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
846 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
847 DALI_TEST_CHECK(value);
848 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
850 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
851 DALI_TEST_CHECK(value);
852 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
854 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
855 DALI_TEST_CHECK(value);
856 DALI_TEST_CHECK(value->Get<int>() == 20);
858 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
859 DALI_TEST_CHECK(value);
860 DALI_TEST_CHECK(value->Get<int>() == 30);
862 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
863 DALI_TEST_CHECK(value);
864 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
866 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
867 DALI_TEST_CHECK(value);
868 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
870 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
871 DALI_TEST_CHECK(value);
872 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
874 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
875 DALI_TEST_CHECK(value);
876 DALI_TEST_CHECK(value->Get<bool>() == true);
881 int UtcDaliVisualGetPropertyMap6(void)
883 ToolkitTestApplication application;
884 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
886 Rect<int> border(1, 1, 1, 1);
888 VisualFactory factory = VisualFactory::Get();
889 Property::Map propertyMap;
890 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
891 propertyMap.Insert("mixColor", Color::MAGENTA);
892 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
893 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
894 propertyMap.Insert(ImageVisual::Property::BORDER, border);
895 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
896 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
897 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
899 Property::Map resultMap;
900 nPatchVisual.CreatePropertyMap(resultMap);
902 // check the property values from the returned map from visual
903 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
904 DALI_TEST_CHECK(value);
905 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
907 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
908 DALI_TEST_CHECK(value);
909 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
911 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
912 DALI_TEST_CHECK(value);
913 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
915 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
916 DALI_TEST_CHECK(value);
917 DALI_TEST_CHECK(value->Get<bool>());
919 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
920 DALI_TEST_CHECK(value);
921 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
923 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
924 DALI_TEST_CHECK(value);
925 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
927 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
928 DALI_TEST_CHECK(value);
929 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
931 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
933 Property::Map propertyMap1;
934 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
935 propertyMap1.Insert("mixColor", Color::MAGENTA);
936 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
937 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
938 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
939 nPatchVisual = factory.CreateVisual(propertyMap1);
941 nPatchVisual.CreatePropertyMap(resultMap);
943 // check the property values from the returned map from visual
944 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
945 DALI_TEST_CHECK(value);
946 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
948 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
949 DALI_TEST_CHECK(value);
950 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
952 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
953 DALI_TEST_CHECK(value);
954 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
956 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
957 DALI_TEST_CHECK(value);
958 DALI_TEST_CHECK(value->Get<bool>());
960 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
961 DALI_TEST_CHECK(value);
962 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
967 int UtcDaliVisualGetPropertyMap7(void)
969 ToolkitTestApplication application;
970 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
972 // request SvgVisual with a property map
973 VisualFactory factory = VisualFactory::Get();
974 Property::Map propertyMap;
975 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
976 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
977 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
978 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
979 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
981 Property::Map resultMap;
982 svgVisual.CreatePropertyMap(resultMap);
983 // check the property values from the returned map from a visual
984 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
985 DALI_TEST_CHECK(value);
986 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
988 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
989 DALI_TEST_CHECK(value);
990 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
992 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
993 DALI_TEST_CHECK(value);
994 DALI_TEST_CHECK(value->Get<bool>() == false);
996 // request SvgVisual with a property map 2
998 propertyMap["visualType"] = Visual::SVG;
999 propertyMap["mixColor"] = Color::WHITE;
1000 propertyMap["url"] = TEST_SVG_FILE_NAME;
1001 propertyMap["atlasing"] = true;
1002 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1005 svgVisual1.CreatePropertyMap(resultMap);
1006 // check the property values from the returned map from a visual
1007 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1008 DALI_TEST_CHECK(value);
1009 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1011 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1012 DALI_TEST_CHECK(value);
1013 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1015 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1016 DALI_TEST_CHECK(value);
1017 DALI_TEST_CHECK(value->Get<bool>() == true);
1019 // request SvgVisual with an URL
1020 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1022 svgVisual2.CreatePropertyMap(resultMap);
1023 // check the property values from the returned map from a visual
1024 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1025 DALI_TEST_CHECK(value);
1026 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1028 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1029 DALI_TEST_CHECK(value);
1030 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1036 int UtcDaliVisualGetPropertyMap8(void)
1038 ToolkitTestApplication application;
1039 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1041 //Request MeshVisual using a property map.
1042 VisualFactory factory = VisualFactory::Get();
1043 Property::Map propertyMap;
1044 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1045 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1046 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1047 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1048 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1049 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1050 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1051 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1053 Property::Map resultMap;
1054 meshVisual.CreatePropertyMap(resultMap);
1055 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1057 //Check values in the result map are identical to the initial map's values.
1058 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1059 DALI_TEST_CHECK(value);
1060 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1062 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1063 DALI_TEST_CHECK(value);
1064 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1066 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1067 DALI_TEST_CHECK(value);
1068 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1070 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1071 DALI_TEST_CHECK(value);
1072 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1074 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1075 DALI_TEST_CHECK(value);
1076 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1078 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1079 DALI_TEST_CHECK(value);
1080 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1085 //Primitive shape visual
1086 int UtcDaliVisualGetPropertyMap9(void)
1088 ToolkitTestApplication application;
1089 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1091 static std::vector<UniformData> customUniforms =
1093 UniformData("mixColor", Property::Type::VECTOR3),
1096 TestGraphicsController& graphics = application.GetGraphicsController();
1097 graphics.AddCustomUniforms(customUniforms);
1099 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1100 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1102 //Request PrimitiveVisual using a property map.
1103 VisualFactory factory = VisualFactory::Get();
1104 Property::Map propertyMap;
1105 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1106 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1107 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1108 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1109 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1110 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1111 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1112 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1113 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1114 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1115 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1116 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1117 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1118 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1120 Property::Map resultMap;
1121 primitiveVisual.CreatePropertyMap(resultMap);
1123 //Check values in the result map are identical to the initial map's values.
1124 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1125 DALI_TEST_CHECK(value);
1126 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1128 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1129 DALI_TEST_CHECK(value);
1130 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1132 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1133 DALI_TEST_CHECK(value);
1134 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1135 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1137 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1138 DALI_TEST_CHECK(value);
1139 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1141 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1142 DALI_TEST_CHECK(value);
1143 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1145 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1146 DALI_TEST_CHECK(value);
1147 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1149 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1150 DALI_TEST_CHECK(value);
1151 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1153 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1154 DALI_TEST_CHECK(value);
1155 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1157 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1158 DALI_TEST_CHECK(value);
1159 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1161 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1162 DALI_TEST_CHECK(value);
1163 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1165 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1166 DALI_TEST_CHECK(value);
1167 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1169 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1170 DALI_TEST_CHECK(value);
1171 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1173 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1174 DALI_TEST_CHECK(value);
1175 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1177 DummyControl actor = DummyControl::New(true);
1178 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1179 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1180 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1181 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1182 application.GetScene().Add(actor);
1184 Animation animation = Animation::New(1.0f);
1185 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1187 application.SendNotification();
1188 application.Render(0);
1189 application.Render(1000);
1190 application.SendNotification();
1192 auto& gl = application.GetGlAbstraction();
1193 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1195 tet_infoline("Check property map after animation");
1197 primitiveVisual.CreatePropertyMap(resultMap);
1198 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1199 DALI_TEST_CHECK(value);
1200 color = value->Get<Vector4>();
1201 // Ignore alpha part
1202 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1208 int UtcDaliVisualGetPropertyMap10(void)
1210 ToolkitTestApplication application;
1211 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1213 //Request PrimitiveVisual using a property map.
1214 VisualFactory factory = VisualFactory::Get();
1216 Property::Map propertyMap;
1217 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1218 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1219 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1220 propertyMap.Insert("enableMarkup", false);
1221 propertyMap.Insert("text", "Hello world");
1222 propertyMap.Insert("fontFamily", "TizenSans");
1224 Property::Map fontStyleMapSet;
1225 fontStyleMapSet.Insert("weight", "bold");
1226 propertyMap.Insert("fontStyle", fontStyleMapSet);
1228 propertyMap.Insert("pointSize", 12.f);
1229 propertyMap.Insert("multiLine", true);
1230 propertyMap.Insert("horizontalAlignment", "CENTER");
1231 propertyMap.Insert("verticalAlignment", "CENTER");
1232 propertyMap.Insert("textColor", Color::RED);
1234 Property::Map shadowMapSet;
1235 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1237 Property::Map underlineMapSet;
1238 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));
1240 Property::Map outlineMapSet;
1241 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1243 Property::Map backgroundMapSet;
1244 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1246 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1248 Property::Map resultMap;
1249 textVisual.CreatePropertyMap(resultMap);
1251 //Check values in the result map are identical to the initial map's values.
1252 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1253 DALI_TEST_CHECK(value);
1254 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1256 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1257 DALI_TEST_CHECK(value);
1258 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1260 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1261 DALI_TEST_CHECK(value);
1262 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1264 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1265 DALI_TEST_CHECK(value);
1266 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1268 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1269 DALI_TEST_CHECK(value);
1271 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1272 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1273 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1275 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1276 DALI_TEST_CHECK(value);
1277 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1279 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1280 DALI_TEST_CHECK(value);
1281 DALI_TEST_CHECK(value->Get<bool>());
1283 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1284 DALI_TEST_CHECK(value);
1285 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1287 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1288 DALI_TEST_CHECK(value);
1289 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1291 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1292 DALI_TEST_CHECK(value);
1293 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1295 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1296 DALI_TEST_CHECK(value);
1297 DALI_TEST_CHECK(!value->Get<bool>());
1299 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1300 DALI_TEST_CHECK(value);
1302 Property::Map shadowMapGet = value->Get<Property::Map>();
1303 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1304 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1306 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1307 DALI_TEST_CHECK(value);
1309 Property::Map underlineMapGet = value->Get<Property::Map>();
1310 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1311 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1313 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1314 DALI_TEST_CHECK(value);
1316 Property::Map outlineMapGet = value->Get<Property::Map>();
1317 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1318 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1320 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1321 DALI_TEST_CHECK(value);
1323 Property::Map backgroundMapGet = value->Get<Property::Map>();
1324 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1325 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1330 int UtcDaliVisualGetPropertyMap11(void)
1332 ToolkitTestApplication application;
1333 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1335 VisualFactory factory = VisualFactory::Get();
1336 DALI_TEST_CHECK(factory);
1338 Property::Map propertyMap;
1339 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1341 Vector2 start(-0.5f, 0.5f);
1342 Vector2 end(0.5f, -0.0f);
1343 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1344 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1345 Vector2 rotate_center(0.0f, 0.4f);
1346 float rotate_amount = 1.57f;
1347 float offset = 100.f;
1349 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1350 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1351 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1353 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1354 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1355 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1356 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1357 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1358 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1359 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1361 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1362 DALI_TEST_CHECK(animatedGradientVisual);
1364 Property::Map resultMap;
1365 animatedGradientVisual.CreatePropertyMap(resultMap);
1367 // check the property values from the returned map from visual
1368 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1369 DALI_TEST_CHECK(value);
1370 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1372 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1373 DALI_TEST_CHECK(value);
1374 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1376 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1377 DALI_TEST_CHECK(value);
1378 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1380 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1381 DALI_TEST_CHECK(value);
1382 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1384 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1385 DALI_TEST_CHECK(value);
1386 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1388 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1389 DALI_TEST_CHECK(value);
1390 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1392 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1393 DALI_TEST_CHECK(value);
1394 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1396 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1397 DALI_TEST_CHECK(value);
1398 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1400 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1401 DALI_TEST_CHECK(value);
1402 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1404 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1405 DALI_TEST_CHECK(value);
1406 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1408 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1409 DALI_TEST_CHECK(value);
1410 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1415 int UtcDaliVisualGetPropertyMap12(void)
1417 ToolkitTestApplication application;
1418 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1420 // Case 1 : Set values by index
1422 tet_printf(" - Set Values by Index\n");
1423 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1424 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1425 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1427 tet_printf("test with delay [%f]\n", _delay);
1428 VisualFactory factory = VisualFactory::Get();
1429 DALI_TEST_CHECK(factory);
1431 Property::Map propertyMap;
1432 Property::Map animationMap;
1433 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1435 float duration = 1.1f;
1436 float delay = _delay;
1437 float repeat_delay = 0.4f;
1439 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1441 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1442 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1444 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1445 animationMap.Clear();
1446 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1447 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1448 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1449 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1450 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1451 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1452 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1453 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1454 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1456 return animationMap;
1459 Vector2 start1(-0.5f, 0.5f);
1460 Vector2 end1(0.5f, -0.5f);
1461 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1462 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1463 Vector2 rotate_center1(0.0f, 0.4f);
1464 float rotate_amount1 = 0.0f;
1465 float offset1 = 0.f;
1467 Vector2 start2(-0.5f, -0.5f);
1468 Vector2 end2(0.5f, 0.5f);
1469 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1470 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1471 Vector2 rotate_center2(0.0f, -0.4f);
1472 float rotate_amount2 = 6.2832f;
1473 float offset2 = 2.f;
1475 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1476 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1477 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1479 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1480 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1481 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1482 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1483 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1484 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1485 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1487 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1488 DALI_TEST_CHECK(animatedGradientVisual);
1490 Property::Map resultMap;
1491 animatedGradientVisual.CreatePropertyMap(resultMap);
1493 // check the property values from the returned map from visual
1494 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1495 DALI_TEST_CHECK(value);
1496 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1498 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1499 DALI_TEST_CHECK(value);
1500 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1502 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1503 DALI_TEST_CHECK(value);
1504 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1506 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1507 DALI_TEST_CHECK(value);
1508 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1510 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 {
1511 tet_printf("Check value at %d\n", line_num);
1512 value = resultMap.Find(index, Property::MAP);
1513 DALI_TEST_CHECK(value);
1514 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1515 Property::Map* temp_map = value->GetMap();
1516 DALI_TEST_CHECK(temp_map);
1518 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1519 Property::Value* res = temp_map->Find(index);
1520 DALI_TEST_CHECK(res);
1524 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1525 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1526 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1527 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1528 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1529 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1530 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1531 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1532 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1535 // check the animation map data is good
1536 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1537 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1538 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1539 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1540 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1541 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1542 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1546 // Case 2 : Set values by string
1548 tet_printf(" - Set Values by String\n");
1549 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1550 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1551 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1553 tet_printf("test with delay [%f]\n", _delay);
1554 VisualFactory factory = VisualFactory::Get();
1555 DALI_TEST_CHECK(factory);
1557 Property::Map propertyMap;
1558 Property::Map animationMap;
1559 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1561 float duration = 1.1f;
1562 float delay = _delay;
1563 float repeat_delay = 0.4f;
1565 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1567 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1568 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1570 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1571 animationMap.Clear();
1572 animationMap.Insert("startValue", start);
1573 animationMap.Insert("targetValue", target);
1574 animationMap.Insert("directionType", "BACKWARD");
1575 animationMap.Insert("duration", duration);
1576 animationMap.Insert("delay", delay);
1577 animationMap.Insert("repeat", loop_count);
1578 animationMap.Insert("repeatDelay", repeat_delay);
1579 animationMap.Insert("motionType", "MIRROR");
1580 animationMap.Insert("easingType", "IN_OUT");
1582 return animationMap;
1585 Vector2 start1(-0.5f, 0.5f);
1586 Vector2 end1(0.5f, -0.5f);
1587 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1588 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1589 Vector2 rotate_center1(0.0f, 0.4f);
1590 float rotate_amount1 = 0.0f;
1591 float offset1 = 0.f;
1593 Vector2 start2(-0.5f, -0.5f);
1594 Vector2 end2(0.5f, 0.5f);
1595 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1596 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1597 Vector2 rotate_center2(0.0f, -0.4f);
1598 float rotate_amount2 = 6.2832f;
1599 float offset2 = 2.f;
1601 // For test mix the type string/index key and string/index value works well.
1602 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1603 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1604 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1606 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1607 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1608 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1609 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1610 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1611 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1612 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1614 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1615 DALI_TEST_CHECK(animatedGradientVisual);
1617 Property::Map resultMap;
1618 animatedGradientVisual.CreatePropertyMap(resultMap);
1620 // check the property values from the returned map from visual
1621 // Note : resultMap from CreatePropertyMap only contain indexKey
1622 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1623 DALI_TEST_CHECK(value);
1624 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1626 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1627 DALI_TEST_CHECK(value);
1628 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1630 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1631 DALI_TEST_CHECK(value);
1632 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1634 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1635 DALI_TEST_CHECK(value);
1636 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1638 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 {
1639 tet_printf("Check value at %d\n", line_num);
1640 value = resultMap.Find(index, Property::MAP);
1641 DALI_TEST_CHECK(value);
1642 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1643 Property::Map* temp_map = value->GetMap();
1644 DALI_TEST_CHECK(temp_map);
1646 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1647 Property::Value* res = temp_map->Find(index);
1648 DALI_TEST_CHECK(res);
1652 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1653 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1654 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1655 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1656 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1657 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1658 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1659 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1660 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1663 // check the animation map data is good
1664 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1665 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1666 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1667 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1668 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1669 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1670 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1676 int UtcDaliVisualGetPropertyMap13(void)
1678 ToolkitTestApplication application;
1679 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1681 for(int _direction = 0; _direction <= 1; ++_direction)
1683 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1685 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1686 VisualFactory factory = VisualFactory::Get();
1687 DALI_TEST_CHECK(factory);
1689 Property::Map propertyMap;
1690 Property::Map animationMap;
1691 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1693 float duration = 1.0f;
1694 float delay = _delay;
1695 float repeat_delay = 0.5f;
1697 int direction = _direction;
1698 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1699 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1700 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1702 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1703 animationMap.Clear();
1704 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1705 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1707 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1709 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1710 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1711 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1712 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1713 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1714 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1715 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1716 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1718 return animationMap;
1721 Vector2 start1(-0.5f, 0.5f);
1722 Vector2 end1(0.5f, -0.5f);
1723 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1724 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1725 Vector2 rotate_center1(1.0f, 0.4f);
1726 float rotate_amount1 = 2.0f;
1727 float offset1 = 1.f;
1729 Vector2 start2(-0.5f, -0.5f);
1730 Vector2 end2(0.5f, 0.5f);
1731 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1732 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1733 Vector2 rotate_center2(1.0f, -0.4f);
1734 float rotate_amount2 = 1.0f;
1735 float offset2 = 3.f;
1737 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1738 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1739 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1741 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1742 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1743 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1744 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1745 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1746 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1747 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1749 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1750 DALI_TEST_CHECK(animatedGradientVisual);
1752 Property::Map resultMap;
1753 animatedGradientVisual.CreatePropertyMap(resultMap);
1755 // check the property values from the returned map from visual
1756 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1757 DALI_TEST_CHECK(value);
1758 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1760 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1761 DALI_TEST_CHECK(value);
1762 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1764 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1765 DALI_TEST_CHECK(value);
1766 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1768 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1769 DALI_TEST_CHECK(value);
1770 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1772 // If loop_count = 0, Animation doesn't created.
1773 // Optimized resultMap only have one value, which is target value
1774 // Note: target value will be changed by direction option.
1775 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1776 DALI_TEST_CHECK(value);
1777 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1779 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1780 DALI_TEST_CHECK(value);
1781 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1783 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1784 DALI_TEST_CHECK(value);
1785 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1787 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1788 DALI_TEST_CHECK(value);
1789 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1791 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1792 DALI_TEST_CHECK(value);
1793 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1795 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1796 DALI_TEST_CHECK(value);
1797 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1799 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1800 DALI_TEST_CHECK(value);
1801 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1808 int UtcDaliVisualAnimateBorderVisual01(void)
1810 ToolkitTestApplication application;
1811 tet_infoline("UtcDaliAnimateBorderVisual Color");
1813 static std::vector<UniformData> customUniforms =
1815 UniformData("borderColor", Property::Type::VECTOR4),
1816 UniformData("mixColor", Property::Type::VECTOR3),
1819 TestGraphicsController& graphics = application.GetGraphicsController();
1820 graphics.AddCustomUniforms(customUniforms);
1822 VisualFactory factory = VisualFactory::Get();
1823 Property::Map propertyMap;
1824 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1825 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1826 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1827 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1828 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1831 map["target"] = "testVisual";
1832 map["property"] = "mixColor";
1833 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1834 map["animator"] = Property::Map()
1835 .Add("alphaFunction", "LINEAR")
1836 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1838 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1840 DummyControl actor = DummyControl::New(true);
1841 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1842 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1843 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1844 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1845 application.GetScene().Add(actor);
1847 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1849 Renderer renderer = actor.GetRendererAt(0);
1850 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1851 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1853 Animation animation = dummyImpl.CreateTransition(transition);
1855 // Animate the mix color through the transition, and the border color through
1856 // programmatic method.
1857 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1860 application.SendNotification();
1861 application.Render(0);
1862 application.Render(2000u); // halfway point between blue and white
1864 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1865 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1866 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1867 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1869 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1870 testColor = Vector4(1, 1, 1, 0.45f);
1871 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1872 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1875 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1876 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1878 application.Render(2000u);
1880 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1881 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1882 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1884 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1885 testColor = Vector4(1, 1, 1, 0.1);
1886 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1887 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1889 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1890 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1895 int UtcDaliVisualAnimateBorderVisual02(void)
1897 ToolkitTestApplication application;
1898 tet_infoline("UtcDaliAnimateBorderVisual Size");
1900 static std::vector<UniformData> customUniforms =
1902 UniformData("borderSize", Property::Type::FLOAT),
1905 TestGraphicsController& graphics = application.GetGraphicsController();
1906 graphics.AddCustomUniforms(customUniforms);
1908 VisualFactory factory = VisualFactory::Get();
1909 Property::Map propertyMap;
1910 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1911 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1912 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1913 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1915 DummyControl actor = DummyControl::New(true);
1916 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1917 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1918 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1919 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1920 application.GetScene().Add(actor);
1922 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1924 Renderer renderer = actor.GetRendererAt(0);
1925 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1927 Animation animation = Animation::New(4.0f);
1928 animation.AnimateTo(Property(renderer, index), 9.0f);
1931 application.SendNotification();
1932 application.Render(0);
1933 application.Render(2000u); // halfway point
1935 float size = renderer.GetCurrentProperty<float>(index);
1936 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1937 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1939 application.Render(2000u); // halfway point between blue and white
1941 size = renderer.GetCurrentProperty<float>(index);
1942 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1943 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1948 int UtcDaliVisualAnimateColorVisual(void)
1950 ToolkitTestApplication application;
1951 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1953 static std::vector<UniformData> customUniforms =
1955 UniformData("mixColor", Property::Type::VECTOR3),
1958 TestGraphicsController& graphics = application.GetGraphicsController();
1959 graphics.AddCustomUniforms(customUniforms);
1961 VisualFactory factory = VisualFactory::Get();
1962 Property::Map propertyMap;
1963 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1964 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1965 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1967 DummyControl actor = DummyControl::New(true);
1968 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1969 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1970 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1971 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1972 application.GetScene().Add(actor);
1974 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1976 Renderer renderer = actor.GetRendererAt(0);
1977 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1979 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1980 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1982 Animation animation = Animation::New(4.0f);
1983 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1986 application.SendNotification();
1987 application.Render(0);
1988 application.Render(2000u); // halfway point
1990 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1991 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
1992 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1994 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1996 application.Render(2000u); // halfway point between blue and white
1998 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1999 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2001 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2003 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2004 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2009 int UtcDaliVisualAnimatePrimitiveVisual(void)
2011 ToolkitTestApplication application;
2012 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2014 static std::vector<UniformData> customUniforms =
2016 UniformData("mixColor", Property::Type::VECTOR3),
2019 TestGraphicsController& graphics = application.GetGraphicsController();
2020 graphics.AddCustomUniforms(customUniforms);
2023 VisualFactory factory = VisualFactory::Get();
2024 Property::Map propertyMap;
2025 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2026 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2027 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2028 Visual::Base visual = factory.CreateVisual(propertyMap);
2030 DummyControl actor = DummyControl::New(true);
2031 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2032 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2033 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2034 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2035 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2036 application.GetScene().Add(actor);
2038 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2040 Renderer renderer = actor.GetRendererAt(0);
2042 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2043 const Vector4 TARGET_MIX_COLOR(Color::RED);
2046 map["target"] = "testVisual";
2047 map["property"] = "mixColor";
2048 map["initialValue"] = INITIAL_MIX_COLOR;
2049 map["targetValue"] = TARGET_MIX_COLOR;
2050 map["animator"] = Property::Map()
2051 .Add("alphaFunction", "LINEAR")
2052 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2054 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2056 Animation animation = dummyImpl.CreateTransition(transition);
2057 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2060 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2061 glAbstraction.EnableEnableDisableCallTrace(true);
2062 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2063 std::ostringstream blendStr;
2064 blendStr << std::hex << GL_BLEND;
2066 application.SendNotification();
2067 application.Render(0);
2068 application.Render(2000u); // halfway point
2069 application.SendNotification();
2071 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2072 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2073 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2075 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2077 glEnableStack.Reset();
2079 application.Render(2001u); // go past end
2080 application.SendNotification(); // Trigger signals
2082 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2083 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2084 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2086 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2094 int UtcDaliVisualAnimatedGradientVisual01(void)
2096 ToolkitTestApplication application;
2097 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2099 static std::vector<UniformData> customUniforms =
2101 UniformData("start_point", Property::Type::VECTOR2),
2102 UniformData("end_point", Property::Type::VECTOR2),
2103 UniformData("start_color", Property::Type::VECTOR4),
2104 UniformData("end_color", Property::Type::VECTOR4),
2105 UniformData("rotate_center", Property::Type::VECTOR2),
2106 UniformData("rotate_angle", Property::Type::FLOAT),
2107 UniformData("gradient_offset", Property::Type::FLOAT),
2110 TestGraphicsController& graphics = application.GetGraphicsController();
2111 graphics.AddCustomUniforms(customUniforms);
2114 VisualFactory factory = VisualFactory::Get();
2115 Property::Map propertyMap;
2116 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2117 Visual::Base visual = factory.CreateVisual(propertyMap);
2119 DummyControl actor = DummyControl::New(true);
2120 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2121 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2122 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2123 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2124 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2125 application.GetScene().Add(actor);
2127 application.SendNotification();
2128 application.Render(0);
2129 application.SendNotification();
2131 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2133 for(int step_iter = 0; step_iter < 3; step_iter++)
2135 application.SendNotification();
2136 application.Render(0);
2137 application.Render(750u); // step i/4
2138 application.SendNotification();
2140 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2141 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2142 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2143 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2144 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2145 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2146 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2149 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2150 application.Render(750u); // go to end
2151 application.SendNotification();
2153 application.Render(10u); // finish
2154 application.SendNotification();
2157 application.SendNotification();
2158 application.Render(0u);
2159 application.SendNotification();
2165 int UtcDaliVisualAnimatedGradientVisual02(void)
2167 ToolkitTestApplication application;
2168 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2170 static std::vector<UniformData> customUniforms =
2172 UniformData("start_point", Property::Type::VECTOR2),
2173 UniformData("end_point", Property::Type::VECTOR2),
2174 UniformData("start_color", Property::Type::VECTOR4),
2175 UniformData("end_color", Property::Type::VECTOR4),
2176 UniformData("rotate_center", Property::Type::VECTOR2),
2177 UniformData("rotate_angle", Property::Type::FLOAT),
2178 UniformData("gradient_offset", Property::Type::FLOAT),
2181 TestGraphicsController& graphics = application.GetGraphicsController();
2182 graphics.AddCustomUniforms(customUniforms);
2185 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
2186 int _direction[2] = {0, 1};
2187 int _loop_count[3] = {-1, 0, 1};
2188 int _motion[2] = {0, 1};
2189 int _easing[4] = {0, 1, 2, 3};
2191 int test_case_max = 4 * 2 * 3 * 2 * 4;
2193 int test_case_d = 7; // 7 is the number of animated properties.
2195 float _duration = 0.4f;
2196 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2197 float noise_maker = 0.0f;
2198 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2199 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2201 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2203 VisualFactory factory = VisualFactory::Get();
2204 Property::Map propertyMap;
2205 Property::Map animationMap;
2206 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2208 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2209 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2210 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2212 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& {
2213 int tc = (test_case + tc_offset);
2214 int idx_easing = tc % 4;
2216 int idx_motion = tc % 2;
2218 int idx_loop_count = tc % 3;
2220 int idx_direction = tc % 2;
2222 int idx_delay = tc % 4;
2225 float duration = _duration - _repeat_delay;
2226 float repeat_delay = _repeat_delay;
2227 float delay = _delay[idx_delay] * _duration;
2228 int direction = _direction[idx_direction];
2229 int loop_count = _loop_count[idx_loop_count];
2230 int motion = _motion[idx_motion];
2231 int easing = _easing[idx_easing];
2233 animationMap.Clear();
2234 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2235 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2238 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2242 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2244 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2245 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2246 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2247 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2250 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2254 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2258 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2260 else if(easing == 1)
2262 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2264 else if(easing == 2)
2266 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2270 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2273 return animationMap;
2276 // Give different values for debuging
2277 noise_maker += 1.0f;
2278 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2279 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2280 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2281 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2282 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2283 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2284 float offset1 = 0.f + noise_maker * 0.1f;
2286 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2287 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2288 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2289 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2290 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2291 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2292 float offset2 = 2.f + noise_maker * 0.1f;
2294 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2295 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2296 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2298 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2299 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2300 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2301 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2302 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2303 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2304 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2306 Visual::Base visual = factory.CreateVisual(propertyMap);
2308 DummyControl actor = DummyControl::New(true);
2309 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2310 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2311 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2312 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2313 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2314 application.GetScene().Add(actor);
2316 application.SendNotification();
2317 application.Render(0);
2318 application.SendNotification();
2320 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2322 application.SendNotification();
2324 //Compare between CPU calculated value and Shader Visual calculated value
2325 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 {
2326 int tc = (test_case + tc_offset);
2327 int idx_easing = tc % 4;
2329 int idx_motion = tc % 2;
2331 int idx_loop_count = tc % 3;
2333 int idx_direction = tc % 2;
2335 int idx_delay = tc % 4;
2338 float duration = _duration - _repeat_delay;
2339 float repeat_delay = _repeat_delay;
2340 float delay = _delay[idx_delay] * _duration;
2341 int direction = _direction[idx_direction];
2342 int loop_count = _loop_count[idx_loop_count];
2343 int motion = _motion[idx_motion];
2344 int easing = _easing[idx_easing];
2346 progress -= delay / _duration;
2348 Property::Value s = start;
2349 Property::Value t = target;
2355 float x; ///< Animator progress value
2360 else if(loop_count > 0 && progress + 0.01f > loop_count)
2362 x = (motion == 0) ? 1.0f : 0.0f;
2370 progress = fmodf(progress, 1.0f);
2371 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2376 x = progress * 2.0f;
2383 if(easing == 1) // EASE_IN
2387 else if(easing == 2) // EASE_OUT
2389 x = 2.0f * x - x * x;
2391 else if(easing == 3) // EASE_IN_OUT
2393 x = x * x * (3.0f - 2.0f * x);
2396 if(value_type == 0) // result type is Float
2400 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2401 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2402 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2404 else if(value_type == 1) // result type is Vector2
2408 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2409 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2410 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2412 else if(value_type == 2) // result type is Vector3
2416 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2417 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2418 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2420 else // result type is Vector4
2424 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2425 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2426 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2431 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2433 for(int step_iter = 0; step_iter < 3; step_iter++)
2435 application.SendNotification();
2436 application.Render(_duration * 250.f); // step i/4
2437 application.SendNotification();
2440 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2441 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2442 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2443 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2444 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2445 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2446 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2448 application.SendNotification();
2449 application.Render(_duration * 250.f); // step 4/4 will not test
2450 application.SendNotification();
2454 application.SendNotification();
2456 application.SendNotification();
2457 application.Render(10.f); // tempral time
2458 application.SendNotification();
2465 int UtcDaliVisualAnimatedGradientVisual03(void)
2467 ToolkitTestApplication application;
2468 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2470 static std::vector<UniformData> customUniforms =
2472 UniformData("start_point", Property::Type::VECTOR2),
2473 UniformData("end_point", Property::Type::VECTOR2),
2474 UniformData("start_color", Property::Type::VECTOR4),
2475 UniformData("end_color", Property::Type::VECTOR4),
2476 UniformData("rotate_center", Property::Type::VECTOR2),
2477 UniformData("rotate_angle", Property::Type::FLOAT),
2478 UniformData("gradient_offset", Property::Type::FLOAT),
2481 TestGraphicsController& graphics = application.GetGraphicsController();
2482 graphics.AddCustomUniforms(customUniforms);
2485 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
2486 int _direction[2] = {0, 1};
2487 int _loop_count[3] = {-1, 0, 1};
2488 int _motion[2] = {0, 1};
2489 int _easing[4] = {0, 1, 2, 3};
2491 int test_case_max = 4 * 2 * 3 * 2 * 4;
2493 int test_case_d = 7; // 7 is the number of animated properties.
2495 float _duration = 0.4f;
2496 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2497 float noise_maker = 0.2f;
2498 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2499 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2501 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2503 VisualFactory factory = VisualFactory::Get();
2504 Property::Map propertyMap;
2505 Property::Map animationMap;
2506 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2508 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& {
2509 int tc = (test_case + tc_offset);
2510 int idx_easing = tc % 4;
2512 int idx_motion = tc % 2;
2514 int idx_loop_count = tc % 3;
2516 int idx_direction = tc % 2;
2518 int idx_delay = tc % 4;
2521 float duration = _duration - _repeat_delay;
2522 float repeat_delay = _repeat_delay;
2523 float delay = _delay[idx_delay] * _duration;
2524 int direction = _direction[idx_direction];
2525 int loop_count = _loop_count[idx_loop_count];
2526 int motion = _motion[idx_motion];
2527 int easing = _easing[idx_easing];
2529 animationMap.Clear();
2530 animationMap.Insert("startValue", start);
2531 animationMap.Insert("targetValue", target);
2534 animationMap.Insert("directionType", "FORWARD");
2538 animationMap.Insert("directionType", "BACKWARD");
2540 animationMap.Insert("duration", duration);
2541 animationMap.Insert("delay", delay);
2542 animationMap.Insert("repeat", loop_count);
2543 animationMap.Insert("repeatDelay", repeat_delay);
2546 animationMap.Insert("motionType", "LOOP");
2550 animationMap.Insert("motionType", "MIRROR");
2554 animationMap.Insert("easingType", "LINEAR");
2556 else if(easing == 1)
2558 animationMap.Insert("easingType", "IN");
2560 else if(easing == 2)
2562 animationMap.Insert("easingType", "OUT");
2566 animationMap.Insert("easingType", "IN_OUT");
2569 return animationMap;
2572 // Give different values for debuging
2573 noise_maker += 0.8f;
2574 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2575 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2576 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2577 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2578 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2579 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2580 float offset1 = 0.f + noise_maker * 0.1f;
2582 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2583 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2584 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2585 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2586 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2587 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2588 float offset2 = 2.f + noise_maker * 0.1f;
2590 propertyMap.Insert("gradientType", "LINEAR");
2591 propertyMap.Insert("unitType", "USER_SPACE");
2592 propertyMap.Insert("spreadType", "CLAMP");
2594 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2595 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2596 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2597 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2598 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2599 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2600 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2602 Visual::Base visual = factory.CreateVisual(propertyMap);
2604 DummyControl actor = DummyControl::New(true);
2605 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2606 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2607 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2608 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2609 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2610 application.GetScene().Add(actor);
2612 application.SendNotification();
2613 application.Render(0);
2614 application.SendNotification();
2616 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2618 application.SendNotification();
2620 //Compare between CPU calculated value and Shader Visual calculated value
2621 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 {
2622 int tc = (test_case + tc_offset);
2623 int idx_easing = tc % 4;
2625 int idx_motion = tc % 2;
2627 int idx_loop_count = tc % 3;
2629 int idx_direction = tc % 2;
2631 int idx_delay = tc % 4;
2634 float duration = _duration - _repeat_delay;
2635 float repeat_delay = _repeat_delay;
2636 float delay = _delay[idx_delay] * _duration;
2637 int direction = _direction[idx_direction];
2638 int loop_count = _loop_count[idx_loop_count];
2639 int motion = _motion[idx_motion];
2640 int easing = _easing[idx_easing];
2642 progress -= delay / _duration;
2644 Property::Value s = start;
2645 Property::Value t = target;
2651 float x; ///< Animator progress value
2656 else if(loop_count > 0 && progress + 0.01f > loop_count)
2658 x = (motion == 0) ? 1.0f : 0.0f;
2666 progress = fmodf(progress, 1.0f);
2667 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2672 x = progress * 2.0f;
2679 if(easing == 1) // EASE_IN
2683 else if(easing == 2) // EASE_OUT
2685 x = 2.0f * x - x * x;
2687 else if(easing == 3) // EASE_IN_OUT
2689 x = x * x * (3.0f - 2.0f * x);
2692 if(value_type == 0) // result type is Float
2696 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2697 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2698 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2700 else if(value_type == 1) // result type is Vector2
2704 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2705 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2706 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2708 else if(value_type == 2) // result type is Vector3
2712 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2713 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2714 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2716 else // result type is Vector4
2720 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2721 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2722 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2727 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2729 for(int step_iter = 0; step_iter < 3; step_iter++)
2731 application.SendNotification();
2732 application.Render(_duration * 250.f); // step i/4
2733 application.SendNotification();
2736 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2737 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2738 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2739 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2740 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2741 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2742 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2744 application.SendNotification();
2745 application.Render(_duration * 250.f); // step 4/4 will not test
2746 application.SendNotification();
2750 application.SendNotification();
2752 application.SendNotification();
2753 application.Render(10.f); // tempral time
2754 application.SendNotification();
2761 int UtcDaliVisualWireframeVisual(void)
2763 ToolkitTestApplication application;
2765 VisualFactory factory = VisualFactory::Get();
2766 Property::Map propertyMap;
2767 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2769 // Create the visual.
2770 Visual::Base visual = factory.CreateVisual(propertyMap);
2772 DALI_TEST_CHECK(visual);
2774 Property::Map resultMap;
2775 visual.CreatePropertyMap(resultMap);
2777 // Check the property values from the returned map from visual
2778 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2779 DALI_TEST_CHECK(value);
2780 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2785 int UtcDaliVisualGetTransform(void)
2787 ToolkitTestApplication application;
2788 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2790 VisualFactory factory = VisualFactory::Get();
2791 Property::Map propertyMap;
2792 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2793 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2794 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2796 Dali::Property::Map visualMap;
2797 colorVisual.CreatePropertyMap(visualMap);
2798 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2799 Dali::Property::Map* map = value->GetMap();
2800 DALI_TEST_CHECK(map);
2802 //Test default values
2804 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2805 DALI_TEST_CHECK(typeValue);
2806 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2809 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2810 DALI_TEST_CHECK(typeValue);
2811 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2814 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2815 DALI_TEST_CHECK(typeValue);
2816 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2819 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2820 DALI_TEST_CHECK(typeValue);
2821 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2824 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2825 DALI_TEST_CHECK(typeValue);
2826 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2829 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2830 DALI_TEST_CHECK(typeValue);
2831 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2834 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2835 DALI_TEST_CHECK(typeValue);
2836 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2842 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2844 Property::Map transform;
2845 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2846 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2847 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2848 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2849 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2850 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2852 visual.SetTransformAndSize(transform, Vector2(100, 100));
2854 Dali::Property::Map visualMap;
2855 visual.CreatePropertyMap(visualMap);
2856 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2857 Dali::Property::Map* map = value->GetMap();
2858 DALI_TEST_CHECK(map);
2861 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2862 DALI_TEST_CHECK(typeValue);
2863 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2866 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2867 DALI_TEST_CHECK(typeValue);
2868 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2871 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2872 DALI_TEST_CHECK(typeValue);
2873 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2876 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2877 DALI_TEST_CHECK(typeValue);
2878 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2881 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2882 DALI_TEST_CHECK(typeValue);
2883 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2886 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2887 DALI_TEST_CHECK(typeValue);
2888 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2891 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2892 DALI_TEST_CHECK(typeValue);
2893 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2896 //Put the visual on the stage
2897 DummyControl actor = DummyControl::New(true);
2898 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2899 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2900 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2901 application.GetScene().Add(actor);
2903 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2904 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2906 application.SendNotification();
2907 application.Render(0);
2908 Renderer renderer(actor.GetRendererAt(0));
2910 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2911 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2913 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2914 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2916 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2917 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2919 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2920 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2922 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2923 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2925 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2926 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2928 //Set a new transform
2930 transform = DefaultTransform();
2931 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2932 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2933 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2934 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2935 visual.SetTransformAndSize(transform, Vector2(100, 100));
2936 application.SendNotification();
2937 application.Render(0);
2939 //Check that the values have changed in the renderer
2940 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2941 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2943 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2944 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2946 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2947 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2949 //Parent origin and anchor point should have the default values
2950 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2951 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2953 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2954 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2956 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2957 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2960 int UtcDaliVisualSetTransform01(void)
2962 ToolkitTestApplication application;
2963 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2965 VisualFactory factory = VisualFactory::Get();
2966 Property::Map propertyMap;
2967 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2968 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2969 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2970 Visual::Base visual = factory.CreateVisual(propertyMap);
2971 TestTransform(application, visual);
2972 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2977 int UtcDaliVisualSetTransform0(void)
2979 ToolkitTestApplication application;
2980 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2982 VisualFactory factory = VisualFactory::Get();
2983 Property::Map propertyMap;
2984 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2985 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2986 Visual::Base visual = factory.CreateVisual(propertyMap);
2987 TestTransform(application, visual);
2988 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2993 int UtcDaliVisualSetTransform1(void)
2995 ToolkitTestApplication application;
2996 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
2998 VisualFactory factory = VisualFactory::Get();
2999 Property::Map propertyMap;
3000 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3001 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3002 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3003 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3004 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3005 Visual::Base visual = factory.CreateVisual(propertyMap);
3006 TestTransform(application, visual);
3007 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3012 int UtcDaliVisualSetTransform2(void)
3014 ToolkitTestApplication application;
3015 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3017 VisualFactory factory = VisualFactory::Get();
3018 Property::Map propertyMap;
3019 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3020 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3022 Property::Array stopOffsets;
3023 stopOffsets.PushBack(0.0f);
3024 stopOffsets.PushBack(0.3f);
3025 stopOffsets.PushBack(0.6f);
3026 stopOffsets.PushBack(0.8f);
3027 stopOffsets.PushBack(1.0f);
3028 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3030 Property::Array stopColors;
3031 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3032 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3033 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3034 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3035 stopColors.PushBack(Color::YELLOW);
3036 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3037 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3038 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3039 Visual::Base visual = factory.CreateVisual(propertyMap);
3040 TestTransform(application, visual);
3041 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3046 int UtcDaliVisualSetTransform3(void)
3048 ToolkitTestApplication application;
3049 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3051 VisualFactory factory = VisualFactory::Get();
3052 Property::Map propertyMap;
3053 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3054 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3055 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3056 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3057 Visual::Base visual = factory.CreateVisual(propertyMap);
3058 TestTransform(application, visual);
3059 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3064 int UtcDaliVisualSetTransform4(void)
3066 ToolkitTestApplication application;
3067 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3069 VisualFactory factory = VisualFactory::Get();
3070 Property::Map propertyMap;
3071 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3072 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3074 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3075 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3076 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3077 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3078 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3079 Visual::Base visual = factory.CreateVisual(propertyMap);
3080 TestTransform(application, visual);
3081 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3086 int UtcDaliVisualSetTransform5(void)
3088 ToolkitTestApplication application;
3089 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3091 VisualFactory factory = VisualFactory::Get();
3092 Property::Map propertyMap;
3093 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3094 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3095 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3096 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3097 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3098 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3099 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3100 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3101 Visual::Base visual = factory.CreateVisual(propertyMap);
3102 TestTransform(application, visual);
3103 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3108 int UtcDaliVisualSetTransform6(void)
3110 ToolkitTestApplication application;
3111 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3113 VisualFactory factory = VisualFactory::Get();
3114 Property::Map propertyMap;
3115 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3116 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3117 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3118 Visual::Base visual = factory.CreateVisual(propertyMap);
3119 TestTransform(application, visual);
3120 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3125 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3127 ToolkitTestApplication application;
3128 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3130 VisualFactory factory = VisualFactory::Get();
3131 Property::Map propertyMap;
3132 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3133 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3134 Visual::Base visual = factory.CreateVisual(propertyMap);
3136 Property::Map transform;
3137 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3138 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3139 visual.SetTransformAndSize(transform, Vector2(100, 100));
3141 Dali::Property::Map visualMap;
3142 visual.CreatePropertyMap(visualMap);
3143 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3144 Dali::Property::Map* map = value->GetMap();
3145 DALI_TEST_CHECK(map);
3148 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3149 DALI_TEST_CHECK(typeValue);
3150 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3153 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3154 DALI_TEST_CHECK(typeValue);
3155 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3161 int UtcDaliNPatchVisualCustomShader(void)
3163 ToolkitTestApplication application;
3164 tet_infoline("NPatchVisual with custom shader");
3166 VisualFactory factory = VisualFactory::Get();
3167 Property::Map properties;
3168 Property::Map shader;
3169 const std::string vertexShader = "Foobar";
3170 const std::string fragmentShader = "Foobar";
3171 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3172 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3174 Property::Map transformMap;
3175 transformMap["size"] = Vector2(0.5f, 0.5f);
3176 transformMap["offset"] = Vector2(20.0f, 0.0f);
3177 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3178 transformMap["anchorPoint"] = Align::CENTER;
3179 transformMap["origin"] = Align::CENTER;
3180 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3181 properties[Visual::Property::TRANSFORM] = transformMap;
3183 properties[Visual::Property::TYPE] = Visual::IMAGE;
3184 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3185 properties[Visual::Property::SHADER] = shader;
3186 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3187 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3189 Visual::Base visual = factory.CreateVisual(properties);
3190 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3192 // trigger creation through setting on stage
3193 DummyControl dummy = DummyControl::New(true);
3194 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3195 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3196 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3197 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3198 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3199 application.GetScene().Add(dummy);
3200 application.SendNotification();
3202 Renderer renderer = dummy.GetRendererAt(0);
3203 Shader shader2 = renderer.GetShader();
3204 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3205 Property::Map* map = value.GetMap();
3206 DALI_TEST_CHECK(map);
3208 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3209 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3211 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3212 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3214 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3215 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3217 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3218 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3223 int UtcDaliGradientVisualBlendMode(void)
3225 ToolkitTestApplication application;
3226 VisualFactory factory = VisualFactory::Get();
3228 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3229 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)));
3231 Visual::Base alphaGradientVisual = factory.CreateVisual(
3232 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))));
3234 DummyControl control = DummyControl::New(true);
3235 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3236 application.GetScene().Add(control);
3238 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3239 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3240 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3242 application.SendNotification();
3243 application.Render();
3245 // 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
3246 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3247 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3248 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3253 int UtcDaliVisualRendererRemovalAndReAddition(void)
3255 ToolkitTestApplication application;
3256 tet_infoline("UtcDaliVisualRendererRemoval");
3258 VisualFactory factory = VisualFactory::Get();
3259 Property::Map propertyMap;
3260 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3261 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3262 Visual::Base visual = factory.CreateVisual(propertyMap);
3264 visual.SetDepthIndex(1);
3266 DummyControl dummyControl = DummyControl::New(true);
3267 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3268 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3269 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3271 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3272 tet_infoline("Add control with visual to stage and check renderer count is 1");
3274 application.GetScene().Add(dummyControl);
3276 application.SendNotification();
3277 application.Render();
3279 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3281 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3282 application.GetScene().Remove(dummyControl);
3283 application.SendNotification();
3284 application.Render();
3286 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3288 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3290 application.GetScene().Add(dummyControl);
3292 application.SendNotification();
3293 application.Render();
3295 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3300 int UtcDaliVisualTextVisualRender(void)
3302 ToolkitTestApplication application;
3303 tet_infoline("UtcDaliVisualTextVisualRender");
3305 VisualFactory factory = VisualFactory::Get();
3306 Property::Map propertyMap;
3307 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3308 propertyMap.Insert("mixColor", Color::WHITE);
3309 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3310 propertyMap.Insert("enableMarkup", false);
3311 propertyMap.Insert("text", "Hello world");
3312 propertyMap.Insert("fontFamily", "TizenSans");
3314 Property::Map fontStyleMapSet;
3315 fontStyleMapSet.Insert("weight", "bold");
3316 propertyMap.Insert("fontStyle", fontStyleMapSet);
3318 propertyMap.Insert("pointSize", 12.f);
3319 propertyMap.Insert("multiLine", true);
3320 propertyMap.Insert("horizontalAlignment", "CENTER");
3321 propertyMap.Insert("verticalAlignment", "CENTER");
3322 propertyMap.Insert("textColor", Color::RED);
3323 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3324 textVisual.SetDepthIndex(1);
3326 DummyControl dummyControl = DummyControl::New(true);
3327 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3328 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3329 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3331 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3332 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3334 application.GetScene().Add(dummyControl);
3335 application.SendNotification();
3336 application.Render();
3338 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3339 propertyMap.Clear();
3340 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3341 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3342 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3343 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3345 Property::Map transformMap;
3346 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3347 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3349 textVisual = factory.CreateVisual(propertyMap);
3350 textVisual.SetDepthIndex(1);
3352 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3353 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3355 application.SendNotification(); // force process events to ensure text visual
3356 // adds renderer to the dummy control in OnRelayout
3357 application.Render();
3359 Renderer renderer = dummyControl.GetRendererAt(0u);
3360 Property::Index index = renderer.GetPropertyIndex("transformSize");
3362 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3363 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3368 int UtcDaliVisualTextVisualDisableEnable(void)
3370 ToolkitTestApplication application;
3371 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3373 VisualFactory factory = VisualFactory::Get();
3374 Property::Map propertyMap;
3375 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3376 propertyMap.Insert("mixColor", Color::WHITE);
3377 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3378 propertyMap.Insert("enableMarkup", false);
3379 propertyMap.Insert("text", "Hello world");
3380 propertyMap.Insert("fontFamily", "TizenSans");
3382 Property::Map fontStyleMapSet;
3383 fontStyleMapSet.Insert("weight", "bold");
3384 propertyMap.Insert("fontStyle", fontStyleMapSet);
3386 propertyMap.Insert("pointSize", 12.f);
3387 propertyMap.Insert("multiLine", true);
3388 propertyMap.Insert("horizontalAlignment", "CENTER");
3389 propertyMap.Insert("verticalAlignment", "CENTER");
3390 propertyMap.Insert("textColor", Color::RED);
3391 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3392 textVisual.SetDepthIndex(1);
3394 DummyControl dummyControl = DummyControl::New(true);
3395 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3396 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3397 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3399 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3400 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3402 application.GetScene().Add(dummyControl);
3403 application.SendNotification();
3404 application.Render();
3406 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3408 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3410 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3412 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3414 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3419 int UtcDaliVisualPremultipliedAlpha(void)
3421 ToolkitTestApplication application;
3422 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3424 VisualFactory factory = VisualFactory::Get();
3426 // image visual, test default value ( true )
3428 Visual::Base imageVisual = factory.CreateVisual(
3430 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3431 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3433 Dali::Property::Map visualMap;
3434 imageVisual.CreatePropertyMap(visualMap);
3435 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3438 DALI_TEST_CHECK(value);
3439 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3442 // image visual, override premultiplied
3444 Visual::Base imageVisual = factory.CreateVisual(
3446 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3447 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3448 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3450 Dali::Property::Map visualMap;
3451 imageVisual.CreatePropertyMap(visualMap);
3452 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3455 DALI_TEST_CHECK(value);
3456 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3459 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3461 Visual::Base imageVisual = factory.CreateVisual(
3463 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3464 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3466 Dali::Property::Map visualMap;
3467 imageVisual.CreatePropertyMap(visualMap);
3468 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3471 DALI_TEST_CHECK(value);
3472 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3475 Visual::Base imageVisual = factory.CreateVisual(
3477 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3478 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3479 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3481 Dali::Property::Map visualMap;
3482 imageVisual.CreatePropertyMap(visualMap);
3483 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3486 DALI_TEST_CHECK(value);
3487 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3490 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3492 Visual::Base imageVisual = factory.CreateVisual(
3494 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3495 .Add(ImageVisual::Property::URL, "something.json"));
3497 Dali::Property::Map visualMap;
3498 imageVisual.CreatePropertyMap(visualMap);
3499 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3502 DALI_TEST_CHECK(value);
3503 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3506 Visual::Base imageVisual = factory.CreateVisual(
3508 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3509 .Add(ImageVisual::Property::URL, "something.json")
3510 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3512 Dali::Property::Map visualMap;
3513 imageVisual.CreatePropertyMap(visualMap);
3514 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3517 DALI_TEST_CHECK(value);
3518 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3521 // text visual ( premultiplied alpha by default is true, and cannot change value )
3523 Visual::Base textVisual = factory.CreateVisual(
3525 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3526 .Add(TextVisual::Property::TEXT, "Text"));
3528 Dali::Property::Map visualMap;
3529 textVisual.CreatePropertyMap(visualMap);
3530 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3533 DALI_TEST_CHECK(value);
3534 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3537 Visual::Base textVisual = factory.CreateVisual(
3539 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3540 .Add(TextVisual::Property::TEXT, "Text")
3541 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3543 Dali::Property::Map visualMap;
3544 textVisual.CreatePropertyMap(visualMap);
3545 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3548 DALI_TEST_CHECK(value);
3549 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3552 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3554 Visual::Base gradientVisual = factory.CreateVisual(
3556 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3557 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3558 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3559 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3561 Dali::Property::Map visualMap;
3562 gradientVisual.CreatePropertyMap(visualMap);
3563 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3566 DALI_TEST_CHECK(value);
3567 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3570 Visual::Base gradientVisual = factory.CreateVisual(
3572 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3573 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3574 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3575 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3576 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3578 Dali::Property::Map visualMap;
3579 gradientVisual.CreatePropertyMap(visualMap);
3580 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3583 DALI_TEST_CHECK(value);
3584 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3587 // color visual ( premultiplied alpha by default is false, and cannot change value )
3589 Visual::Base colorVisual = factory.CreateVisual(
3591 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3592 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3594 Dali::Property::Map visualMap;
3595 colorVisual.CreatePropertyMap(visualMap);
3596 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3599 DALI_TEST_CHECK(value);
3600 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3603 Visual::Base colorVisual = factory.CreateVisual(
3605 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3606 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3607 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3609 Dali::Property::Map visualMap;
3610 colorVisual.CreatePropertyMap(visualMap);
3611 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3614 DALI_TEST_CHECK(value);
3615 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3621 int UtcDaliRegisterVisualOrder(void)
3623 ToolkitTestApplication application;
3624 tet_infoline("Register Visual Order");
3626 DummyControl dummyControl = DummyControl::New(true);
3627 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3629 VisualFactory factory = VisualFactory::Get();
3630 Property::Map propertyMap;
3631 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3632 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3634 tet_infoline("Register visual, should have depth index of 0.0f");
3635 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3636 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3637 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3639 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3641 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3642 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3643 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3645 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3646 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3647 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3649 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3650 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3651 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3653 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3654 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3655 labelVisual.SetDepthIndex(-2000);
3656 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3657 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3659 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3660 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3661 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3662 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3663 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3664 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3666 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3667 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3668 anotherTestVisual2Replacement.SetDepthIndex(2000);
3669 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3670 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3672 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3673 application.GetScene().Add(dummyControl);
3678 int UtcDaliRegisterVisualOrder02(void)
3680 ToolkitTestApplication application;
3681 tet_infoline("Register Visual Order with Background Set");
3683 DummyControl dummyControl = DummyControl::New(true);
3684 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3686 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3688 VisualFactory factory = VisualFactory::Get();
3689 Property::Map propertyMap;
3690 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3691 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3693 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3695 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3697 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3698 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3699 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3700 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3701 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3703 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3704 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3705 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3706 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3708 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3709 application.GetScene().Add(dummyControl);
3714 int UtcDaliRegisterVisualWithDepthIndex(void)
3716 ToolkitTestApplication application;
3717 tet_infoline("Register a Visual With Depth Index");
3719 DummyControl dummyControl = DummyControl::New(true);
3720 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3722 VisualFactory factory = VisualFactory::Get();
3723 Property::Map propertyMap;
3724 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3725 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3727 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3728 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3729 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3730 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3731 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3733 tet_infoline("Register another visual with a depth index and it disabled");
3734 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3735 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3736 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3737 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3739 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3740 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3741 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3742 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3743 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3745 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3746 application.GetScene().Add(dummyControl);
3751 int UtcDaliSvgVisualCustomShader(void)
3753 ToolkitTestApplication application;
3754 tet_infoline("SvgVisual with custom shader");
3756 VisualFactory factory = VisualFactory::Get();
3757 Property::Map properties;
3758 Property::Map shader;
3759 const std::string vertexShader = "Foobar";
3760 const std::string fragmentShader = "Foobar";
3761 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3762 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3764 properties[Visual::Property::TYPE] = Visual::IMAGE;
3765 properties[Visual::Property::SHADER] = shader;
3766 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3768 Visual::Base visual = factory.CreateVisual(properties);
3770 // trigger creation through setting on stage
3771 DummyControl dummy = DummyControl::New(true);
3772 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3773 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3775 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3776 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3777 application.GetScene().Add(dummy);
3779 application.SendNotification();
3780 application.Render();
3782 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3784 Renderer renderer = dummy.GetRendererAt(0);
3785 Shader shader2 = renderer.GetShader();
3786 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3787 Property::Map* map = value.GetMap();
3788 DALI_TEST_CHECK(map);
3790 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3791 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3793 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3794 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3799 int UtcDaliVisualRoundedCorner(void)
3801 ToolkitTestApplication application;
3802 tet_infoline("UtcDaliVisualRoundedCorner");
3804 static std::vector<UniformData> customUniforms =
3806 UniformData("cornerRadius", Property::Type::VECTOR4),
3807 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3810 TestGraphicsController& graphics = application.GetGraphicsController();
3811 graphics.AddCustomUniforms(customUniforms);
3815 VisualFactory factory = VisualFactory::Get();
3816 Property::Map properties;
3817 float cornerRadius = 30.0f;
3819 properties[Visual::Property::TYPE] = Visual::IMAGE;
3820 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3821 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3823 Visual::Base visual = factory.CreateVisual(properties);
3825 // trigger creation through setting on stage
3826 DummyControl dummy = DummyControl::New(true);
3827 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3828 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3830 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3831 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3832 application.GetScene().Add(dummy);
3834 application.SendNotification();
3835 application.Render();
3837 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3839 application.SendNotification();
3840 application.Render();
3842 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3843 // Default corner radius policy is absolute.
3844 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3849 VisualFactory factory = VisualFactory::Get();
3850 Property::Map properties;
3851 float cornerRadius = 30.0f;
3853 properties[Visual::Property::TYPE] = Visual::COLOR;
3854 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3855 properties["cornerRadius"] = cornerRadius;
3856 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3858 Visual::Base visual = factory.CreateVisual(properties);
3860 // trigger creation through setting on stage
3861 DummyControl dummy = DummyControl::New(true);
3862 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3863 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3865 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3866 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3867 application.GetScene().Add(dummy);
3869 application.SendNotification();
3870 application.Render();
3872 application.SendNotification();
3873 application.Render();
3875 // Currently test with multiple program doesn't work well. will fix another day
3876 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3877 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3882 VisualFactory factory = VisualFactory::Get();
3883 Property::Map properties;
3884 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3886 properties[Visual::Property::TYPE] = Visual::COLOR;
3887 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3888 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3889 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3891 Visual::Base visual = factory.CreateVisual(properties);
3893 // trigger creation through setting on stage
3894 DummyControl dummy = DummyControl::New(true);
3895 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3896 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3898 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3899 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3900 application.GetScene().Add(dummy);
3902 application.SendNotification();
3903 application.Render();
3905 application.SendNotification();
3906 application.Render();
3908 // Currently test with multiple program doesn't work well. will fix another day
3909 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3910 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3913 // color visual 3 - invalid value
3915 VisualFactory factory = VisualFactory::Get();
3916 Property::Map properties;
3917 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3919 properties[Visual::Property::TYPE] = Visual::COLOR;
3920 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3921 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3922 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3924 Visual::Base visual = factory.CreateVisual(properties);
3926 // trigger creation through setting on stage
3927 DummyControl dummy = DummyControl::New(true);
3928 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3929 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3931 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3932 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3933 application.GetScene().Add(dummy);
3935 application.SendNotification();
3936 application.Render();
3938 application.SendNotification();
3939 application.Render();
3941 // Currently test with multiple program doesn't work well. will fix another day
3942 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3943 // Default corner radius policy is absolute.
3944 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3949 VisualFactory factory = VisualFactory::Get();
3950 Property::Map properties;
3951 float cornerRadius = 30.0f;
3953 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3954 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3955 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3956 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3957 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3958 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3960 Property::Array stopOffsets;
3961 stopOffsets.PushBack(0.0f);
3962 stopOffsets.PushBack(0.6f);
3963 stopOffsets.PushBack(1.0f);
3964 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3966 Property::Array stopColors;
3967 stopColors.PushBack(Color::RED);
3968 stopColors.PushBack(Color::YELLOW);
3969 stopColors.PushBack(Color::GREEN);
3970 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3972 Visual::Base visual = factory.CreateVisual(properties);
3974 // trigger creation through setting on stage
3975 DummyControl dummy = DummyControl::New(true);
3976 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3977 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3979 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3980 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3981 application.GetScene().Add(dummy);
3983 application.SendNotification();
3984 application.Render();
3986 application.SendNotification();
3987 application.Render();
3989 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3990 // Default corner radius policy is absolute.
3991 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3994 // animated image visual
3996 VisualFactory factory = VisualFactory::Get();
3997 Property::Map properties;
3998 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4000 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4001 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4002 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4003 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4004 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4006 Visual::Base visual = factory.CreateVisual(properties);
4008 // trigger creation through setting on stage
4009 DummyControl dummy = DummyControl::New(true);
4010 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4011 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4013 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4014 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4015 application.GetScene().Add(dummy);
4017 application.SendNotification();
4018 application.Render();
4020 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4022 application.SendNotification();
4023 application.Render();
4025 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4026 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4029 // vector image visual
4031 VisualFactory factory = VisualFactory::Get();
4032 Property::Map properties;
4033 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4035 properties[Visual::Property::TYPE] = Visual::SVG;
4036 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4037 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4039 Visual::Base visual = factory.CreateVisual(properties);
4041 // trigger creation through setting on stage
4042 DummyControl dummy = DummyControl::New(true);
4043 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4044 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4046 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4047 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4048 application.GetScene().Add(dummy);
4050 application.SendNotification();
4051 application.Render();
4053 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4055 application.SendNotification();
4056 application.Render();
4058 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4059 // Default corner radius policy is absolute.
4060 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4063 // animated vector image visual
4065 VisualFactory factory = VisualFactory::Get();
4066 Property::Map properties;
4067 float cornerRadius = 1.3f;
4069 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4070 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4071 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4072 properties["cornerRadius"] = cornerRadius;
4073 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4075 Visual::Base visual = factory.CreateVisual(properties);
4077 // trigger creation through setting on stage
4078 DummyControl dummy = DummyControl::New(true);
4079 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4080 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4082 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4083 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4084 application.GetScene().Add(dummy);
4086 application.SendNotification();
4087 application.Render();
4089 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4091 application.SendNotification();
4092 application.Render();
4094 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4095 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4101 int UtcDaliVisualBorderline(void)
4103 ToolkitTestApplication application;
4104 tet_infoline("UtcDaliVisualBorderline");
4106 static std::vector<UniformData> customUniforms =
4108 UniformData("cornerRadius", Property::Type::VECTOR4),
4109 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4110 UniformData("borderlineWidth", Property::Type::FLOAT),
4111 UniformData("borderlineColor", Property::Type::VECTOR4),
4112 UniformData("borderlineOffset", Property::Type::FLOAT),
4115 TestGraphicsController& graphics = application.GetGraphicsController();
4116 graphics.AddCustomUniforms(customUniforms);
4120 VisualFactory factory = VisualFactory::Get();
4121 Property::Map properties;
4122 float cornerRadius = 5.0f;
4123 float borderlineWidth = 30.0f;
4124 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4125 float borderlineOffset = 1.0f;
4127 properties[Visual::Property::TYPE] = Visual::IMAGE;
4128 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4129 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4130 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4131 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4132 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4134 Visual::Base visual = factory.CreateVisual(properties);
4136 // trigger creation through setting on stage
4137 DummyControl dummy = DummyControl::New(true);
4138 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4139 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4141 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4142 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4143 application.GetScene().Add(dummy);
4145 application.SendNotification();
4146 application.Render();
4148 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4150 application.SendNotification();
4151 application.Render();
4153 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4154 // Default corner radius policy is absolute.
4155 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4156 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4157 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4158 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4163 VisualFactory factory = VisualFactory::Get();
4164 Property::Map properties;
4165 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4166 float borderlineWidth = 30.0f;
4167 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4168 float borderlineOffset = -0.4f;
4170 properties[Visual::Property::TYPE] = Visual::COLOR;
4171 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4172 properties["cornerRadius"] = cornerRadius;
4173 properties["borderlineWidth"] = borderlineWidth;
4174 properties["borderlineColor"] = borderlineColor;
4175 properties["borderlineOffset"] = borderlineOffset;
4177 Visual::Base visual = factory.CreateVisual(properties);
4179 // trigger creation through setting on stage
4180 DummyControl dummy = DummyControl::New(true);
4181 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4182 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4184 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4185 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4186 application.GetScene().Add(dummy);
4188 application.SendNotification();
4189 application.Render();
4191 application.SendNotification();
4192 application.Render();
4194 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4195 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4196 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4197 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4200 // color visual 2, default color, default offset
4202 VisualFactory factory = VisualFactory::Get();
4203 Property::Map properties;
4204 float borderlineWidth = 30.0f;
4206 properties[Visual::Property::TYPE] = Visual::COLOR;
4207 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4208 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4210 Visual::Base visual = factory.CreateVisual(properties);
4212 // trigger creation through setting on stage
4213 DummyControl dummy = DummyControl::New(true);
4214 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4215 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4217 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4218 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4219 application.GetScene().Add(dummy);
4221 application.SendNotification();
4222 application.Render();
4224 application.SendNotification();
4225 application.Render();
4227 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4228 // Default borderline color is BLACK.
4229 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4230 // Default borderline offset is 0.0f.
4231 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4234 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4236 VisualFactory factory = VisualFactory::Get();
4237 Property::Map properties;
4238 float borderlineWidth = 30.0f;
4239 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4240 float borderlineOffset = 37.4f;
4242 properties[Visual::Property::TYPE] = Visual::COLOR;
4243 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4244 properties["borderlineWidth"] = borderlineWidth;
4245 properties["borderlineColor"] = borderlineColor;
4246 properties["borderlineOffset"] = borderlineOffset;
4248 Visual::Base visual = factory.CreateVisual(properties);
4250 // trigger creation through setting on stage
4251 DummyControl dummy = DummyControl::New(true);
4252 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4253 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4255 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4256 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4257 application.GetScene().Add(dummy);
4259 application.SendNotification();
4260 application.Render();
4262 application.SendNotification();
4263 application.Render();
4265 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4266 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4267 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4268 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4273 VisualFactory factory = VisualFactory::Get();
4274 Property::Map properties;
4275 float borderlineWidth = 30.0f;
4276 float cornerRadius = 70.0f;
4278 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4279 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4280 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4281 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4282 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4283 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4284 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4286 Property::Array stopOffsets;
4287 stopOffsets.PushBack(0.0f);
4288 stopOffsets.PushBack(0.6f);
4289 stopOffsets.PushBack(1.0f);
4290 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4292 Property::Array stopColors;
4293 stopColors.PushBack(Color::RED);
4294 stopColors.PushBack(Color::YELLOW);
4295 stopColors.PushBack(Color::GREEN);
4296 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4298 Visual::Base visual = factory.CreateVisual(properties);
4300 // trigger creation through setting on stage
4301 DummyControl dummy = DummyControl::New(true);
4302 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4303 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4305 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4306 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4307 application.GetScene().Add(dummy);
4309 application.SendNotification();
4310 application.Render();
4312 application.SendNotification();
4313 application.Render();
4315 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4316 // Default corner radius policy is absolute.
4317 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4318 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4319 // Default borderline color is BLACK.
4320 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4321 // Default borderline offset is 0.0f.
4322 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4325 // animated image visual
4327 VisualFactory factory = VisualFactory::Get();
4328 Property::Map properties;
4329 float borderlineWidth = 24.0f;
4330 float borderlineOffset = -1.0f;
4332 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4333 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4334 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4335 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4336 properties["borderlineOffset"] = borderlineOffset;
4338 Visual::Base visual = factory.CreateVisual(properties);
4340 // trigger creation through setting on stage
4341 DummyControl dummy = DummyControl::New(true);
4342 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4343 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4345 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4346 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4347 application.GetScene().Add(dummy);
4349 application.SendNotification();
4350 application.Render();
4352 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4354 application.SendNotification();
4355 application.Render();
4357 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4358 // Default borderline color is BLACK.
4359 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4360 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4363 // vector image visual
4365 VisualFactory factory = VisualFactory::Get();
4366 Property::Map properties;
4367 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4368 float borderlineWidth = 27.0f;
4369 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4371 properties[Visual::Property::TYPE] = Visual::SVG;
4372 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4373 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4374 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4375 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4377 Visual::Base visual = factory.CreateVisual(properties);
4379 // trigger creation through setting on stage
4380 DummyControl dummy = DummyControl::New(true);
4381 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4382 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4384 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4385 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4386 application.GetScene().Add(dummy);
4388 application.SendNotification();
4389 application.Render();
4391 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4393 application.SendNotification();
4394 application.Render();
4396 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4397 // Default corner radius policy is absolute.
4398 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4399 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4400 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4401 // Default borderline offset is 0.0.
4402 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4405 // animated vector image visual
4407 VisualFactory factory = VisualFactory::Get();
4408 Property::Map properties;
4409 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4410 float borderlineWidth = 13.0f;
4411 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4412 float borderlineOffset = 13.0f;
4414 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4415 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4416 properties["cornerRadius"] = cornerRadius;
4417 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4418 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4419 properties["borderlineColor"] = borderlineColor;
4420 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4422 Visual::Base visual = factory.CreateVisual(properties);
4424 // trigger creation through setting on stage
4425 DummyControl dummy = DummyControl::New(true);
4426 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4427 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4429 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4430 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4431 application.GetScene().Add(dummy);
4433 application.SendNotification();
4434 application.Render();
4436 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4438 application.SendNotification();
4439 application.Render();
4441 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4442 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4443 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4444 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4445 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4451 int UtcDaliVisualBorderlineBlendModeTest(void)
4453 ToolkitTestApplication application;
4454 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4455 VisualFactory factory = VisualFactory::Get();
4457 // Case 1 : Test which doesn't support borderline feature.
4459 tet_printf("Test Unsupported visual type\n");
4460 Property::Map propertyMap;
4461 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4462 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4463 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4464 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4466 DummyControl actor = DummyControl::New(true);
4467 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4468 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4469 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4470 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4471 application.GetScene().Add(actor);
4473 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4475 Renderer renderer = actor.GetRendererAt(0);
4477 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4478 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4479 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4481 application.GetScene().Remove(actor);
4484 // Case 2 : Test which support borderline feature.
4486 tet_printf("Test normal case\n");
4487 Property::Map propertyMap;
4488 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4489 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4490 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4491 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4493 DummyControl actor = DummyControl::New(true);
4494 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4495 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4496 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4497 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4498 application.GetScene().Add(actor);
4500 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4502 Renderer renderer = actor.GetRendererAt(0);
4504 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4505 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4506 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4508 application.GetScene().Remove(actor);
4511 // Case 3 : Test which animated borderline.
4513 tet_printf("Test borderline animate case\n");
4514 Property::Map propertyMap;
4515 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4516 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4517 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4519 DummyControl actor = DummyControl::New(true);
4520 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4521 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4522 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4523 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4524 application.GetScene().Add(actor);
4526 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4528 Renderer renderer = actor.GetRendererAt(0);
4530 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4531 // BlendMode is AUTO.
4532 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4534 Animation animation = Animation::New(0.1f);
4535 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4538 application.SendNotification();
4539 application.Render();
4540 application.Render(101u); // End of animation
4542 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4543 // BlendMode is ON_WITHOUT_CULL.
4544 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4546 Animation revanimation = Animation::New(0.1f);
4547 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4548 revanimation.Play();
4550 application.SendNotification();
4551 application.Render();
4552 application.Render(101u); // End of animation
4554 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4555 // BlendMode is still ON_WITHOUT_CULL.
4556 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4558 application.GetScene().Remove(actor);
4561 // Case 4 : Test which animated corner radius occur.
4563 tet_printf("Test borderline animate case\n");
4564 Property::Map propertyMap;
4565 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4566 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4567 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4568 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4570 DummyControl actor = DummyControl::New(true);
4571 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4572 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4573 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4574 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4575 application.GetScene().Add(actor);
4577 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4579 Renderer renderer = actor.GetRendererAt(0);
4581 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4582 // BlendMode is ON_WITHOUT_CULL.
4583 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4585 Animation animation = Animation::New(0.1f);
4586 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4589 application.SendNotification();
4590 application.Render();
4591 application.Render(101u); // End of animation
4593 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4594 // BlendMode is ON_WITHOUT_CULL.
4595 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4597 application.GetScene().Remove(actor);
4603 int UtcDaliVisualBorderlineColorAnimateTest(void)
4605 ToolkitTestApplication application;
4606 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4608 TestGraphicsController& graphics = application.GetGraphicsController();
4609 static std::vector<UniformData> customUniforms =
4611 UniformData("mixColor", Property::Type::VECTOR3),
4612 UniformData("cornerRadius", Property::Type::VECTOR4),
4613 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4614 UniformData("borderlineWidth", Property::Type::FLOAT),
4615 UniformData("borderlineColor", Property::Type::VECTOR4),
4616 UniformData("borderlineOffset", Property::Type::FLOAT),
4618 graphics.AddCustomUniforms(customUniforms);
4621 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4622 const float INITIAL_MIX_OPACITY(0.5f);
4623 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4624 const float INITIAL_ACTOR_OPACITY(1.0f);
4625 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4626 const float TARGET_MIX_OPACITY(0.8f);
4627 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4628 const float TARGET_ACTOR_OPACITY(0.5f);
4630 VisualFactory factory = VisualFactory::Get();
4631 Property::Map propertyMap;
4632 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4633 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4634 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4635 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4636 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4637 Visual::Base visual = factory.CreateVisual(propertyMap);
4639 DummyControl actor = DummyControl::New(true);
4640 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4641 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4642 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4643 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4644 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4645 application.GetScene().Add(actor);
4647 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4649 Animation animation = Animation::New(4.0f);
4650 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4651 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4652 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4653 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4656 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4658 application.SendNotification();
4659 application.Render(0);
4660 application.Render(2000u); // halfway point
4661 application.SendNotification();
4663 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4664 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4665 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4666 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4667 halfwayMixOpacity *= halfwayActorOpacity;
4668 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4669 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4670 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4671 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4673 application.Render(2001u); // go past end
4674 application.SendNotification(); // Trigger signals
4676 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4677 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4678 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4679 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4680 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4688 int UtcDaliColorVisualBlurRadius(void)
4690 ToolkitTestApplication application;
4691 tet_infoline("UtcDaliColorVisualBlurRadius");
4693 static std::vector<UniformData> customUniforms =
4695 UniformData("blurRadius", Property::Type::FLOAT),
4698 TestGraphicsController& graphics = application.GetGraphicsController();
4699 graphics.AddCustomUniforms(customUniforms);
4701 VisualFactory factory = VisualFactory::Get();
4702 Property::Map properties;
4703 float blurRadius = 20.0f;
4705 properties[Visual::Property::TYPE] = Visual::COLOR;
4706 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4707 properties["blurRadius"] = blurRadius;
4709 Visual::Base visual = factory.CreateVisual(properties);
4711 // trigger creation through setting on stage
4712 DummyControl dummy = DummyControl::New(true);
4713 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4714 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4716 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4717 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4718 application.GetScene().Add(dummy);
4720 application.SendNotification();
4721 application.Render();
4723 application.SendNotification();
4724 application.Render();
4726 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4731 int UtcDaliVisualGetType(void)
4733 ToolkitTestApplication application;
4734 tet_infoline("UtcDaliVisualGetType");
4736 VisualFactory factory = VisualFactory::Get();
4739 Property::Map properties;
4740 properties[Visual::Property::TYPE] = Visual::BORDER;
4741 Visual::Base visual = factory.CreateVisual(properties);
4743 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4747 Property::Map properties;
4748 properties[Visual::Property::TYPE] = Visual::COLOR;
4749 Visual::Base visual = factory.CreateVisual(properties);
4751 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4755 Property::Map properties;
4756 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4757 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4758 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4759 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4760 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4761 Property::Array stopColors;
4762 stopColors.PushBack(Color::RED);
4763 stopColors.PushBack(Color::GREEN);
4764 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4765 Visual::Base visual = factory.CreateVisual(properties);
4767 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4771 Property::Map properties;
4772 properties[Visual::Property::TYPE] = Visual::IMAGE;
4773 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4774 Visual::Base visual = factory.CreateVisual(properties);
4776 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4780 Property::Map properties;
4781 properties[Visual::Property::TYPE] = Visual::MESH;
4782 Visual::Base visual = factory.CreateVisual(properties);
4784 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4788 Property::Map properties;
4789 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4790 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4791 Visual::Base visual = factory.CreateVisual(properties);
4793 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4797 Property::Map properties;
4798 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4799 Visual::Base visual = factory.CreateVisual(properties);
4801 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4805 Property::Map properties;
4806 properties[Visual::Property::TYPE] = Visual::TEXT;
4807 Visual::Base visual = factory.CreateVisual(properties);
4809 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4813 Property::Map properties;
4814 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4815 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4816 Visual::Base visual = factory.CreateVisual(properties);
4818 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4822 Property::Map properties;
4823 properties[Visual::Property::TYPE] = Visual::SVG;
4824 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4825 Visual::Base visual = factory.CreateVisual(properties);
4827 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4831 Property::Map properties;
4832 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4833 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4834 Visual::Base visual = factory.CreateVisual(properties);
4836 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4840 Property::Map properties;
4841 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4842 Visual::Base visual = factory.CreateVisual(properties);
4844 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4848 Property::Map properties;
4849 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4850 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4851 Visual::Base visual = factory.CreateVisual(properties);
4853 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4857 Property::Map properties;
4858 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4859 Visual::Base visual = factory.CreateVisual(properties);
4861 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4867 int UtcDaliVisualGetVisualProperty01(void)
4869 ToolkitTestApplication application;
4870 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4872 static std::vector<UniformData> customUniforms =
4874 UniformData("mixColor", Property::Type::VECTOR3),
4875 UniformData("offset", Property::Type::VECTOR2),
4876 UniformData("size", Property::Type::VECTOR2),
4877 UniformData("cornerRadius", Property::Type::VECTOR4),
4878 UniformData("blurRadius", Property::Type::FLOAT),
4879 UniformData("borderlineWidth", Property::Type::FLOAT),
4880 UniformData("borderlineColor", Property::Type::VECTOR4),
4881 UniformData("borderlineOffset", Property::Type::FLOAT)};
4883 TestGraphicsController& graphics = application.GetGraphicsController();
4884 graphics.AddCustomUniforms(customUniforms);
4886 VisualFactory factory = VisualFactory::Get();
4887 Property::Map propertyMap;
4888 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4889 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4890 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4891 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4892 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4893 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4894 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4895 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4896 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4898 DummyControl dummyControl = DummyControl::New(true);
4899 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4900 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4901 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4902 application.GetScene().Add(dummyControl);
4904 application.SendNotification();
4905 application.Render();
4907 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4908 Vector2 targetOffset(0.05f, 0.05f);
4909 Vector2 targetSize(1.1f, 1.1f);
4910 float targetOpacity = 0.5f;
4911 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4912 float targetBlurRadius = 10.0f;
4913 float targetBorderlineWidth = 25.0f;
4914 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4915 float targetBorderlineOffset = -1.0f;
4917 Animation animation = Animation::New(1.0f);
4918 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4919 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4920 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4921 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4922 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4923 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4924 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4925 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4926 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4929 application.SendNotification();
4930 application.Render();
4931 application.Render(1001u); // End of animation
4933 Property::Map resultMap;
4934 colorVisual.CreatePropertyMap(resultMap);
4936 // Test property values: they should be updated
4937 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4938 DALI_TEST_CHECK(colorValue);
4939 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4941 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4942 Dali::Property::Map* transformMap = transformValue->GetMap();
4943 DALI_TEST_CHECK(transformMap);
4945 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4946 DALI_TEST_CHECK(offsetValue);
4947 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4949 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4950 DALI_TEST_CHECK(sizeValue);
4951 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4953 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4954 DALI_TEST_CHECK(cornerRadiusValue);
4955 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4957 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4958 DALI_TEST_CHECK(blurRadiusValue);
4959 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4961 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4962 DALI_TEST_CHECK(borderlineWidthValue);
4963 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4965 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4966 DALI_TEST_CHECK(borderlineColorValue);
4967 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4969 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4970 DALI_TEST_CHECK(borderlineOffsetValue);
4971 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4973 // Test uniform values
4974 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4975 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4976 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4977 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4978 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4979 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4980 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4981 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4983 // Test unregistered visual
4984 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4985 DALI_TEST_CHECK(!property3.object);
4986 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4991 int UtcDaliVisualGetVisualProperty02(void)
4993 ToolkitTestApplication application;
4994 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
4996 static std::vector<UniformData> customUniforms =
4998 UniformData("mixColor", Property::Type::VECTOR3),
4999 UniformData("offset", Property::Type::VECTOR2),
5000 UniformData("size", Property::Type::VECTOR2),
5001 UniformData("cornerRadius", Property::Type::VECTOR4),
5002 UniformData("borderlineWidth", Property::Type::FLOAT),
5003 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5004 UniformData("borderlineOffset", Property::Type::FLOAT),
5005 UniformData("blurRadius", Property::Type::FLOAT),
5008 TestGraphicsController& graphics = application.GetGraphicsController();
5009 graphics.AddCustomUniforms(customUniforms);
5011 VisualFactory factory = VisualFactory::Get();
5012 Property::Map propertyMap;
5013 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5014 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5016 DummyControl dummyControl = DummyControl::New(true);
5017 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5018 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5019 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5020 application.GetScene().Add(dummyControl);
5022 application.SendNotification();
5023 application.Render();
5025 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5026 Vector2 targetOffset(0.05f, 0.05f);
5027 Vector2 targetSize(1.1f, 1.1f);
5028 float targetOpacity = 0.5f;
5029 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5030 float targetBorderlineWidth = 77.7f;
5031 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5032 float targetBorderlineOffset = 1.0f;
5033 float targetBlurRadius = 10.0f;
5035 // Should work when the properties are not set before
5036 Animation animation = Animation::New(1.0f);
5037 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5038 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5039 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5040 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5041 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5042 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5043 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5044 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5045 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5048 application.SendNotification();
5049 application.Render();
5050 application.Render(1001u); // End of animation
5052 Property::Map resultMap;
5053 colorVisual.CreatePropertyMap(resultMap);
5055 // Test property values: they should be updated
5056 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5057 DALI_TEST_CHECK(colorValue);
5058 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5060 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5061 Dali::Property::Map* transformMap = transformValue->GetMap();
5062 DALI_TEST_CHECK(transformMap);
5064 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5065 DALI_TEST_CHECK(offsetValue);
5066 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5068 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5069 DALI_TEST_CHECK(sizeValue);
5070 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5072 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5073 DALI_TEST_CHECK(cornerRadiusValue);
5074 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5076 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5077 DALI_TEST_CHECK(borderlineWidthValue);
5078 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5080 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5081 DALI_TEST_CHECK(borderlineColorValue);
5082 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5084 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5085 DALI_TEST_CHECK(borderlineOffsetValue);
5086 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5088 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5089 DALI_TEST_CHECK(blurRadiusValue);
5090 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5092 // Test uniform values
5093 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5094 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5095 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5096 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5097 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5102 int UtcDaliVisualGetVisualProperty03(void)
5104 ToolkitTestApplication application;
5105 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5107 static std::vector<UniformData> customUniforms =
5109 UniformData("cornerRadius", Property::Type::VECTOR4),
5110 UniformData("borderlineWidth", Property::Type::FLOAT),
5111 UniformData("borderlineColor", Property::Type::VECTOR4),
5112 UniformData("borderlineOffset", Property::Type::FLOAT),
5115 TestGraphicsController& graphics = application.GetGraphicsController();
5116 graphics.AddCustomUniforms(customUniforms);
5118 VisualFactory factory = VisualFactory::Get();
5119 Property::Map propertyMap;
5120 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5121 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5123 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5125 DummyControl dummyControl = DummyControl::New(true);
5126 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5127 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5128 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5129 application.GetScene().Add(dummyControl);
5131 // Wait for image loading
5132 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5134 application.SendNotification();
5135 application.Render();
5137 float targetOpacity = 0.5f;
5138 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5139 float targetBorderlineWidth = 10.0f;
5140 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5141 float targetBorderlineOffset = -1.5f;
5143 Animation animation = Animation::New(1.0f);
5144 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5145 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5146 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5147 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5148 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5151 application.SendNotification();
5152 application.Render();
5153 application.Render(1001u); // End of animation
5155 Property::Map resultMap;
5156 imageVisual.CreatePropertyMap(resultMap);
5158 // Test property values: they should be updated
5159 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5160 DALI_TEST_CHECK(colorValue);
5161 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5163 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5164 DALI_TEST_CHECK(cornerRadiusValue);
5165 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5167 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5168 DALI_TEST_CHECK(borderlineWidthValue);
5169 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5171 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5172 DALI_TEST_CHECK(borderlineColorValue);
5173 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5175 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5176 DALI_TEST_CHECK(borderlineOffsetValue);
5177 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5179 // Test uniform value
5180 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5181 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5182 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5183 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5188 int UtcDaliVisualGetVisualProperty04(void)
5190 ToolkitTestApplication application;
5191 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5193 static std::vector<UniformData> customUniforms =
5195 UniformData("cornerRadius", Property::Type::VECTOR4),
5198 TestGraphicsController& graphics = application.GetGraphicsController();
5199 graphics.AddCustomUniforms(customUniforms);
5201 Vector2 start(-1.f, -1.f);
5202 Vector2 end(1.f, 1.f);
5203 Property::Array stopColors;
5204 stopColors.PushBack(Color::RED);
5205 stopColors.PushBack(Color::GREEN);
5207 VisualFactory factory = VisualFactory::Get();
5208 Property::Map propertyMap;
5209 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5210 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5211 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5212 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5213 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5214 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5215 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5217 DummyControl dummyControl = DummyControl::New(true);
5218 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5219 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5220 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5221 application.GetScene().Add(dummyControl);
5223 application.SendNotification();
5224 application.Render();
5226 float targetOpacity = 0.5f;
5227 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5229 Animation animation = Animation::New(1.0f);
5230 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5231 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5234 application.SendNotification();
5235 application.Render();
5236 application.Render(1001u); // End of animation
5238 Property::Map resultMap;
5239 gradientVisual.CreatePropertyMap(resultMap);
5241 // Test property values: they should be updated
5242 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5243 DALI_TEST_CHECK(colorValue);
5244 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5246 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5247 DALI_TEST_CHECK(cornerRadiusValue);
5248 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5250 // Test uniform value
5251 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5256 int UtcDaliVisualGetVisualProperty05(void)
5258 ToolkitTestApplication application;
5259 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5261 static std::vector<UniformData> customUniforms =
5263 UniformData("cornerRadius", Property::Type::VECTOR4),
5264 UniformData("borderlineWidth", Property::Type::FLOAT),
5265 UniformData("borderlineColor", Property::Type::VECTOR4),
5266 UniformData("borderlineOffset", Property::Type::FLOAT),
5269 TestGraphicsController& graphics = application.GetGraphicsController();
5270 graphics.AddCustomUniforms(customUniforms);
5272 VisualFactory factory = VisualFactory::Get();
5273 Property::Map propertyMap;
5274 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5275 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5277 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5279 DummyControl dummyControl = DummyControl::New(true);
5280 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5281 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5282 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5283 application.GetScene().Add(dummyControl);
5285 application.SendNotification();
5286 application.Render();
5288 // Wait for image loading
5289 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5291 application.SendNotification();
5292 application.Render();
5294 float targetOpacity = 0.5f;
5295 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5296 float targetBorderlineWidth = 10.0f;
5297 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5298 float targetBorderlineOffset = -1.5f;
5300 Animation animation = Animation::New(1.0f);
5301 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5302 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5303 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5304 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5305 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5308 application.SendNotification();
5309 application.Render();
5310 application.Render(1001u); // End of animation
5312 Property::Map resultMap;
5313 svgVisual.CreatePropertyMap(resultMap);
5315 // Test property values: they should be updated
5316 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5317 DALI_TEST_CHECK(colorValue);
5318 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5320 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5321 DALI_TEST_CHECK(cornerRadiusValue);
5322 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5324 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5325 DALI_TEST_CHECK(borderlineWidthValue);
5326 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5328 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5329 DALI_TEST_CHECK(borderlineColorValue);
5330 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5332 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5333 DALI_TEST_CHECK(borderlineOffsetValue);
5334 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5336 // Currently test with multiple program doesn't work well. will fix another day
5337 // Test uniform value
5338 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5339 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5340 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5341 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5346 int UtcDaliVisualGetVisualProperty06(void)
5348 ToolkitTestApplication application;
5349 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5351 static std::vector<UniformData> customUniforms =
5353 UniformData("cornerRadius", Property::Type::VECTOR4),
5354 UniformData("borderlineWidth", Property::Type::FLOAT),
5355 UniformData("borderlineColor", Property::Type::VECTOR4),
5356 UniformData("borderlineOffset", Property::Type::FLOAT),
5359 TestGraphicsController& graphics = application.GetGraphicsController();
5360 graphics.AddCustomUniforms(customUniforms);
5362 VisualFactory factory = VisualFactory::Get();
5363 Property::Map propertyMap;
5364 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5365 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5367 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5369 DummyControl dummyControl = DummyControl::New(true);
5370 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5371 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5372 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5373 application.GetScene().Add(dummyControl);
5375 application.SendNotification();
5376 application.Render();
5378 // Wait for image loading
5379 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5381 application.SendNotification();
5382 application.Render();
5384 float targetOpacity = 0.5f;
5385 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5386 float targetBorderlineWidth = 10.0f;
5387 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5388 float targetBorderlineOffset = -1.5f;
5390 Animation animation = Animation::New(1.0f);
5391 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5392 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5393 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5394 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5395 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5398 application.SendNotification();
5399 application.Render();
5400 application.Render(1001u); // End of animation
5402 Property::Map resultMap;
5403 animatedImageVisual.CreatePropertyMap(resultMap);
5405 // Test property values: they should be updated
5406 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5407 DALI_TEST_CHECK(colorValue);
5408 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5410 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5411 DALI_TEST_CHECK(cornerRadiusValue);
5412 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5414 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5415 DALI_TEST_CHECK(borderlineWidthValue);
5416 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5418 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5419 DALI_TEST_CHECK(borderlineColorValue);
5420 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5422 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5423 DALI_TEST_CHECK(borderlineOffsetValue);
5424 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5426 // Currently test with multiple program doesn't work well. will fix another day
5427 // Test uniform value
5428 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5429 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5430 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5431 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5436 int UtcDaliVisualGetVisualProperty07(void)
5438 ToolkitTestApplication application;
5439 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5441 static std::vector<UniformData> customUniforms =
5443 UniformData("cornerRadius", Property::Type::VECTOR4),
5444 UniformData("borderlineWidth", Property::Type::FLOAT),
5445 UniformData("borderlineColor", Property::Type::VECTOR4),
5446 UniformData("borderlineOffset", Property::Type::FLOAT),
5449 TestGraphicsController& graphics = application.GetGraphicsController();
5450 graphics.AddCustomUniforms(customUniforms);
5452 VisualFactory factory = VisualFactory::Get();
5453 Property::Map propertyMap;
5454 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5455 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5457 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5459 DummyControl dummyControl = DummyControl::New(true);
5460 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5461 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5462 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5463 application.GetScene().Add(dummyControl);
5465 application.SendNotification();
5466 application.Render();
5468 // Wait for image loading
5469 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5471 application.SendNotification();
5472 application.Render();
5474 float targetOpacity = 0.5f;
5475 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5476 float targetBorderlineWidth = 10.0f;
5477 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5478 float targetBorderlineOffset = -1.5f;
5480 Animation animation = Animation::New(1.0f);
5481 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5482 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5483 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5484 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5485 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5488 application.SendNotification();
5489 application.Render();
5490 application.Render(1001u); // End of animation
5492 Property::Map resultMap;
5493 animatedVectorVisual.CreatePropertyMap(resultMap);
5495 // Test property values: they should be updated
5496 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5497 DALI_TEST_CHECK(colorValue);
5498 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5500 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5501 DALI_TEST_CHECK(cornerRadiusValue);
5502 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5504 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5505 DALI_TEST_CHECK(borderlineWidthValue);
5506 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5508 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5509 DALI_TEST_CHECK(borderlineColorValue);
5510 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5512 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5513 DALI_TEST_CHECK(borderlineOffsetValue);
5514 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5516 // Currently test with multiple program doesn't work well. will fix another day
5517 // Test uniform value
5518 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5519 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5520 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5521 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5526 int UtcDaliVisualUpdateProperty(void)
5528 ToolkitTestApplication application;
5529 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5531 VisualFactory factory = VisualFactory::Get();
5532 Property::Map propertyMap;
5533 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5534 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5535 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5536 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5538 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5540 DummyControl dummyControl = DummyControl::New(true);
5541 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5542 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5543 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5544 application.GetScene().Add(dummyControl);
5546 application.SendNotification();
5547 application.Render();
5549 // Wait for image loading
5550 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5552 application.SendNotification();
5553 application.Render();
5555 Property::Map originalMap;
5556 imageVisual.CreatePropertyMap(originalMap);
5558 float targetOpacity = 0.5f;
5559 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5560 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5561 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5563 Property::Map targetPropertyMap;
5564 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5565 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5566 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5567 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5568 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5570 // Update Properties
5571 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5573 Property::Map resultMap;
5574 imageVisual.CreatePropertyMap(resultMap);
5576 // Test property values: they should be updated
5577 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5578 DALI_TEST_CHECK(colorValue);
5579 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5581 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5582 DALI_TEST_CHECK(urlValue);
5583 // NOTE : ImageVisual URL must NOT changed.
5584 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5586 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5587 DALI_TEST_CHECK(preMultipliedValue);
5588 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5590 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5591 DALI_TEST_CHECK(visualFittingModeValue);
5592 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5597 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5599 ToolkitTestApplication application;
5600 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5602 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5604 VisualFactory factory = VisualFactory::Get();
5605 Property::Map propertyMap;
5607 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5608 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5610 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5612 DummyControl dummyControl = DummyControl::New(true);
5613 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5614 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5615 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5616 application.GetScene().Add(dummyControl);
5618 application.SendNotification();
5619 application.Render();
5621 // Wait for image loading
5622 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5624 application.SendNotification();
5625 application.Render();
5629 Renderer renderer = dummyControl.GetRendererAt(0);
5630 Shader shader = renderer.GetShader();
5631 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5632 Property::Map* map = value.GetMap();
5633 DALI_TEST_CHECK(map);
5635 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5636 DALI_TEST_CHECK(fragment);
5637 std::string fragmentShader;
5638 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5639 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5640 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5642 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5643 std::string vertexShader;
5644 DALI_TEST_CHECK(vertex->Get(vertexShader));
5645 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5646 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5649 callStack.Enable(true);
5651 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5653 Property::Map targetPropertyMap;
5654 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5655 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5657 // Update Properties with CornerRadius
5658 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5660 Property::Map resultMap;
5661 imageVisual.CreatePropertyMap(resultMap);
5663 // Test property values: they should be updated
5664 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5665 DALI_TEST_CHECK(cornerRadiusValue);
5666 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5668 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5669 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5670 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5674 Renderer renderer = dummyControl.GetRendererAt(0);
5675 Shader shader = renderer.GetShader();
5676 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5677 Property::Map* map = value.GetMap();
5678 DALI_TEST_CHECK(map);
5680 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5681 DALI_TEST_CHECK(fragment);
5682 std::string fragmentShader;
5683 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5684 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5685 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5687 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5688 std::string vertexShader;
5689 DALI_TEST_CHECK(vertex->Get(vertexShader));
5690 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5691 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5694 // Send shader compile signal
5695 application.SendNotification();
5696 application.Render();
5698 callStack.Enable(false);
5700 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5702 callStack.Enable(true);
5704 float targetBorderlineWidth = 10.0f;
5705 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5706 float targetBorderlineOffset = -0.3f;
5708 Property::Map targetPropertyMap2;
5709 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5710 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5711 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5712 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5713 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5715 // Update Properties with Borderline
5716 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5718 Property::Map resultMap2;
5719 imageVisual.CreatePropertyMap(resultMap2);
5721 // Test property values: they should be updated
5722 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5723 DALI_TEST_CHECK(cornerRadiusValue);
5724 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5726 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5727 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5728 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5730 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5731 DALI_TEST_CHECK(borderlineWidthValue);
5732 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5734 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5735 DALI_TEST_CHECK(borderlineColorValue);
5736 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5738 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5739 DALI_TEST_CHECK(borderlineOffsetValue);
5740 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5744 Renderer renderer = dummyControl.GetRendererAt(0);
5745 Shader shader = renderer.GetShader();
5746 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5747 Property::Map* map = value.GetMap();
5748 DALI_TEST_CHECK(map);
5750 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5751 DALI_TEST_CHECK(fragment);
5752 std::string fragmentShader;
5753 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5754 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5755 // Note : mAlwaysUsingCornerRadius is true.
5756 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5758 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5759 std::string vertexShader;
5760 DALI_TEST_CHECK(vertex->Get(vertexShader));
5761 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5762 // Note : mAlwaysUsingCornerRadius is true.
5763 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5766 // Send shader compile signal
5767 application.SendNotification();
5768 application.Render();
5770 callStack.Enable(false);
5772 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5774 callStack.Enable(true);
5776 Property::Map targetPropertyMap3;
5777 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5778 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5779 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5780 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5781 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5783 // Update Properties into zero
5784 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5786 Property::Map resultMap3;
5787 imageVisual.CreatePropertyMap(resultMap3);
5789 // Test property values: they should be updated
5790 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5791 DALI_TEST_CHECK(cornerRadiusValue);
5792 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5794 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5795 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5796 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5798 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5799 DALI_TEST_CHECK(borderlineWidthValue);
5800 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5802 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5803 DALI_TEST_CHECK(borderlineColorValue);
5804 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5806 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5807 DALI_TEST_CHECK(borderlineOffsetValue);
5808 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5812 Renderer renderer = dummyControl.GetRendererAt(0);
5813 Shader shader = renderer.GetShader();
5814 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5815 Property::Map* map = value.GetMap();
5816 DALI_TEST_CHECK(map);
5818 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5819 DALI_TEST_CHECK(fragment);
5820 std::string fragmentShader;
5821 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5822 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5823 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5824 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5826 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5827 std::string vertexShader;
5828 DALI_TEST_CHECK(vertex->Get(vertexShader));
5829 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5830 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5831 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5834 // Send shader compile signal
5835 application.SendNotification();
5836 application.Render();
5838 callStack.Enable(false);
5839 // Shader not changed
5840 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5845 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5847 ToolkitTestApplication application;
5848 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5850 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5852 VisualFactory factory = VisualFactory::Get();
5853 Property::Map propertyMap;
5855 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5856 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5858 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5860 DummyControl dummyControl = DummyControl::New(true);
5861 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5862 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5863 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5864 application.GetScene().Add(dummyControl);
5866 application.SendNotification();
5867 application.Render();
5869 // Wait for image loading
5870 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5872 application.SendNotification();
5873 application.Render();
5877 Renderer renderer = dummyControl.GetRendererAt(0);
5878 Shader shader = renderer.GetShader();
5879 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5880 Property::Map* map = value.GetMap();
5881 DALI_TEST_CHECK(map);
5883 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5884 DALI_TEST_CHECK(fragment);
5885 std::string fragmentShader;
5886 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5887 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5888 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5890 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5891 std::string vertexShader;
5892 DALI_TEST_CHECK(vertex->Get(vertexShader));
5893 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5894 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5897 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5899 Property::Map targetPropertyMap;
5900 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5903 callStack.Enable(true);
5905 // Update Properties with CornerRadius
5906 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5908 Property::Map resultMap;
5909 imageVisual.CreatePropertyMap(resultMap);
5911 // Test property values: they should be updated
5912 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5913 DALI_TEST_CHECK(cornerRadiusValue);
5914 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5918 Renderer renderer = dummyControl.GetRendererAt(0);
5919 Shader shader = renderer.GetShader();
5920 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5921 Property::Map* map = value.GetMap();
5922 DALI_TEST_CHECK(map);
5924 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5925 DALI_TEST_CHECK(fragment);
5926 std::string fragmentShader;
5927 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5928 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5929 // Note : corner radius is zero. so we don't change shader!
5930 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5932 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5933 std::string vertexShader;
5934 DALI_TEST_CHECK(vertex->Get(vertexShader));
5935 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5936 // Note : corner radius is zero. so we don't change shader!
5937 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5940 // Send shader compile signal
5941 application.SendNotification();
5942 application.Render();
5944 callStack.Enable(false);
5946 // Shader doesn't changed
5947 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5949 callStack.Enable(true);
5951 float targetBorderlineWidth = 0.0f;
5952 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5953 float targetBorderlineOffset = -1.0f;
5955 Property::Map targetPropertyMap2;
5956 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5957 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5958 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5960 // Update Properties with Borderline
5961 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5963 Property::Map resultMap2;
5964 imageVisual.CreatePropertyMap(resultMap2);
5966 // Test property values: they should be updated
5967 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5968 DALI_TEST_CHECK(borderlineWidthValue);
5969 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5971 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5972 DALI_TEST_CHECK(borderlineColorValue);
5973 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5975 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5976 DALI_TEST_CHECK(borderlineOffsetValue);
5977 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5981 Renderer renderer = dummyControl.GetRendererAt(0);
5982 Shader shader = renderer.GetShader();
5983 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5984 Property::Map* map = value.GetMap();
5985 DALI_TEST_CHECK(map);
5987 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5988 DALI_TEST_CHECK(fragment);
5989 std::string fragmentShader;
5990 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5991 // Note : borderline width is zero. so we don't change shader!
5992 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5993 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5995 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5996 std::string vertexShader;
5997 DALI_TEST_CHECK(vertex->Get(vertexShader));
5998 // Note : borderline width is zero. so we don't change shader!
5999 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6000 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6003 // Send shader compile signal
6004 application.SendNotification();
6005 application.Render();
6007 callStack.Enable(false);
6009 // Shader doesn't changed
6010 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6015 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6017 ToolkitTestApplication application;
6018 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6020 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6022 VisualFactory factory = VisualFactory::Get();
6023 Property::Map propertyMap;
6025 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6026 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6028 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6030 DummyControl dummyControl = DummyControl::New(true);
6031 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6032 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6033 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6034 application.GetScene().Add(dummyControl);
6036 application.SendNotification();
6037 application.Render();
6039 application.SendNotification();
6040 application.Render();
6044 Renderer renderer = dummyControl.GetRendererAt(0);
6045 Shader shader = renderer.GetShader();
6046 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6047 Property::Map* map = value.GetMap();
6048 DALI_TEST_CHECK(map);
6050 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6051 DALI_TEST_CHECK(fragment);
6052 std::string fragmentShader;
6053 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6054 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6055 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6056 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6058 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6059 std::string vertexShader;
6060 DALI_TEST_CHECK(vertex->Get(vertexShader));
6061 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6062 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6063 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6066 float targetBlurRadius = 15.0f;
6067 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6069 Property::Map targetPropertyMap;
6070 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6071 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6072 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6075 callStack.Enable(true);
6077 // Update Properties with CornerRadius
6078 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6080 Property::Map resultMap;
6081 imageVisual.CreatePropertyMap(resultMap);
6083 // Test property values: they should be updated
6084 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6085 DALI_TEST_CHECK(blurRadiusValue);
6086 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6088 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6089 DALI_TEST_CHECK(cornerRadiusValue);
6090 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6094 Renderer renderer = dummyControl.GetRendererAt(0);
6095 Shader shader = renderer.GetShader();
6096 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6097 Property::Map* map = value.GetMap();
6098 DALI_TEST_CHECK(map);
6100 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6101 DALI_TEST_CHECK(fragment);
6102 std::string fragmentShader;
6103 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6104 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6105 // Note : We ignore borderline when blur radius occured
6106 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6107 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6109 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6110 std::string vertexShader;
6111 DALI_TEST_CHECK(vertex->Get(vertexShader));
6112 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6113 // Note : We ignore borderline when blur radius occured
6114 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6115 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6118 // Send shader compile signal
6119 application.SendNotification();
6120 application.Render();
6122 callStack.Enable(false);
6125 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6127 callStack.Enable(true);
6129 Property::Map targetPropertyMap2;
6130 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6131 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6132 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6134 // Update Properties with CornerRadius
6135 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6137 Property::Map resultMap2;
6138 imageVisual.CreatePropertyMap(resultMap2);
6140 // Test property values: they should be updated
6141 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6142 DALI_TEST_CHECK(blurRadiusValue);
6143 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6145 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6146 DALI_TEST_CHECK(cornerRadiusValue);
6147 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6151 Renderer renderer = dummyControl.GetRendererAt(0);
6152 Shader shader = renderer.GetShader();
6153 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6154 Property::Map* map = value.GetMap();
6155 DALI_TEST_CHECK(map);
6157 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6158 DALI_TEST_CHECK(fragment);
6159 std::string fragmentShader;
6160 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6161 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6162 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6163 // Note : We ignore borderline when blur radius occured
6164 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6165 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6167 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6168 std::string vertexShader;
6169 DALI_TEST_CHECK(vertex->Get(vertexShader));
6170 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6171 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6172 // Note : We ignore borderline when blur radius occured
6173 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6174 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6177 // Send shader compile signal
6178 application.SendNotification();
6179 application.Render();
6181 callStack.Enable(false);
6183 // Shader not changed
6184 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6189 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6191 ToolkitTestApplication application;
6192 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6194 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6196 VisualFactory factory = VisualFactory::Get();
6197 Property::Map propertyMap;
6199 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6200 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6201 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6203 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6205 DummyControl dummyControl = DummyControl::New(true);
6206 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6207 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6208 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6209 application.GetScene().Add(dummyControl);
6211 application.SendNotification();
6212 application.Render();
6214 // Wait for image loading
6215 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6217 application.SendNotification();
6218 application.Render();
6222 Renderer renderer = dummyControl.GetRendererAt(0);
6223 Shader shader = renderer.GetShader();
6224 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6225 Property::Map* map = value.GetMap();
6226 DALI_TEST_CHECK(map);
6228 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6229 DALI_TEST_CHECK(fragment);
6230 std::string fragmentShader;
6231 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6232 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6233 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6235 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6236 std::string vertexShader;
6237 DALI_TEST_CHECK(vertex->Get(vertexShader));
6238 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6239 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6242 callStack.Enable(true);
6244 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6246 Animation animation = Animation::New(1.0f);
6247 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6250 application.SendNotification();
6251 application.Render();
6252 application.Render(1001u); // End of animation
6256 Renderer renderer = dummyControl.GetRendererAt(0);
6257 Shader shader = renderer.GetShader();
6258 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6259 Property::Map* map = value.GetMap();
6260 DALI_TEST_CHECK(map);
6262 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6263 DALI_TEST_CHECK(fragment);
6264 std::string fragmentShader;
6265 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6266 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6267 // Note : mAlwaysUsingCornerRadius is true.
6268 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6270 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6271 std::string vertexShader;
6272 DALI_TEST_CHECK(vertex->Get(vertexShader));
6273 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6274 // Note : mAlwaysUsingCornerRadius is true.
6275 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6277 callStack.Enable(false);
6278 // Shader not changed
6279 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6281 callStack.Enable(true);
6283 float targetBorderlineWidth = 10.0f;
6284 Property::Map targetPropertyMap;
6285 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6287 // Update Properties with CornerRadius
6288 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6290 Property::Map resultMap;
6291 imageVisual.CreatePropertyMap(resultMap);
6293 // Test property values: they should be updated
6294 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6295 DALI_TEST_CHECK(cornerRadiusValue);
6296 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6298 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6299 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6300 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6302 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6303 DALI_TEST_CHECK(borderlineWidthValue);
6304 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6308 Renderer renderer = dummyControl.GetRendererAt(0);
6309 Shader shader = renderer.GetShader();
6310 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6311 Property::Map* map = value.GetMap();
6312 DALI_TEST_CHECK(map);
6314 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6315 DALI_TEST_CHECK(fragment);
6316 std::string fragmentShader;
6317 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6318 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6319 // Note : mAlwaysUsingCornerRadius is true.
6320 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6322 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6323 std::string vertexShader;
6324 DALI_TEST_CHECK(vertex->Get(vertexShader));
6325 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6326 // Note : mAlwaysUsingCornerRadius is true.
6327 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6330 // Send shader compile signal
6331 application.SendNotification();
6332 application.Render();
6334 callStack.Enable(false);
6336 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));