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
329 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
330 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
331 animatedGradientVisual.GetNaturalSize(naturalSize);
332 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
333 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
337 // Load some fonts to get the same metrics on different platforms.
338 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
339 fontClient.SetDpi(96u, 96u);
341 char* pathNamePtr = get_current_dir_name();
342 const std::string pathName(pathNamePtr);
345 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
347 // Create a TextVisual with a font size of 12 first
349 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
350 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
351 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
352 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
354 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
355 Vector2 smallTextVisualNaturalSize;
356 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
358 // Then create a TextVisual with a font size of 20
359 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
360 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
361 Vector2 largeTextVisualNaturalSize;
362 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
364 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
365 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
366 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
368 // The height returned for a particular width should also be greater for the large text visual
369 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
371 //AnimatedImageVisual
372 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
373 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
374 animatedImageVisual.GetNaturalSize(naturalSize);
375 // TEST_GIF_FILE: anim.gif
376 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
377 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
382 int UtcDaliVisualSetOnOffScene(void)
384 ToolkitTestApplication application;
385 tet_infoline("UtcDaliVisualSetOnOffScene");
387 VisualFactory factory = VisualFactory::Get();
388 Property::Map propertyMap;
389 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
390 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
391 Visual::Base visual = factory.CreateVisual(propertyMap);
393 DummyControl actor = DummyControl::New(true);
394 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
395 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
397 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
399 application.SendNotification();
400 application.Render(0);
401 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
403 application.GetScene().Add(actor);
405 application.SendNotification();
406 application.Render(0);
407 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
409 application.GetScene().Remove(actor);
411 application.SendNotification();
412 application.Render(0);
413 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
418 int UtcDaliVisualSetOnOffScene2(void)
420 ToolkitTestApplication application;
421 tet_infoline("UtcDaliVisualSetOnOffScene2");
423 VisualFactory factory = VisualFactory::Get();
424 Property::Map propertyMap;
425 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
426 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
427 Visual::Base visual = factory.CreateVisual(propertyMap);
429 DummyControl actor = DummyControl::New(true);
430 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
431 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
433 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
435 application.SendNotification();
436 application.Render(0);
437 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
440 application.GetScene().Add(actor);
442 application.SendNotification();
443 application.Render(0);
444 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
445 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
446 Renderer renderer = actor.GetRendererAt(0);
447 auto textures = renderer.GetTextures();
448 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
450 application.GetScene().Remove(actor);
452 application.SendNotification();
453 application.Render(0);
454 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
457 application.GetScene().Add(actor);
459 application.SendNotification();
460 application.Render(0);
461 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
462 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
463 renderer = actor.GetRendererAt(0);
464 textures = renderer.GetTextures();
465 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
467 application.GetScene().Remove(actor);
469 application.SendNotification();
470 application.Render(0);
471 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
476 int UtcDaliVisualGetPropertyMap1(void)
478 ToolkitTestApplication application;
479 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
481 VisualFactory factory = VisualFactory::Get();
482 Property::Map propertyMap;
483 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
484 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
485 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
486 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
487 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
488 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
489 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
490 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
491 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
493 Property::Map resultMap;
494 colorVisual.CreatePropertyMap(resultMap);
496 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
497 DALI_TEST_CHECK(typeValue);
498 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
500 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
501 DALI_TEST_CHECK(colorValue);
502 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
504 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
505 DALI_TEST_CHECK(cornerRadiusValue);
506 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
508 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
509 DALI_TEST_CHECK(cornerRadiusPolicyValue);
510 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
512 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
513 DALI_TEST_CHECK(borderlineWidthValue);
514 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
516 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
517 DALI_TEST_CHECK(borderlineColorValue);
518 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
520 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
521 DALI_TEST_CHECK(borderlineOffsetValue);
522 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
524 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
525 DALI_TEST_CHECK(blurRadiusValue);
526 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
528 // change the blend color
529 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
530 colorVisual = factory.CreateVisual(propertyMap);
531 colorVisual.CreatePropertyMap(resultMap);
533 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
534 DALI_TEST_CHECK(colorValue);
535 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
538 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
540 colorVisual = factory.CreateVisual(propertyMap);
541 colorVisual.CreatePropertyMap(resultMap);
543 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
544 DALI_TEST_CHECK(blurRadiusValue);
545 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
550 int UtcDaliVisualGetPropertyMap2(void)
552 ToolkitTestApplication application;
553 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
555 VisualFactory factory = VisualFactory::Get();
556 Property::Map propertyMap;
557 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
558 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
559 propertyMap.Insert("borderColor", Color::BLUE);
560 propertyMap.Insert("borderSize", 5.f);
561 propertyMap.Insert("antiAliasing", true);
562 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
564 Property::Map resultMap;
565 borderVisual.CreatePropertyMap(resultMap);
567 // check the property values from the returned map from visual
568 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
569 DALI_TEST_CHECK(typeValue);
570 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
572 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
573 DALI_TEST_CHECK(colorValue);
574 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
576 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
577 DALI_TEST_CHECK(sizeValue);
578 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
580 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
581 DALI_TEST_CHECK(AAValue);
582 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
584 Property::Map propertyMap1;
585 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
586 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
587 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
588 borderVisual = factory.CreateVisual(propertyMap1);
589 borderVisual.CreatePropertyMap(resultMap);
591 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
592 DALI_TEST_CHECK(typeValue);
593 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
595 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
596 DALI_TEST_CHECK(colorValue);
597 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
599 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
600 DALI_TEST_CHECK(sizeValue);
601 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
606 int UtcDaliVisualGetPropertyMap2N(void)
608 ToolkitTestApplication application;
609 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
611 VisualFactory factory = VisualFactory::Get();
612 Property::Map propertyMap;
613 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
614 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
616 tet_infoline("Test that the visual is created, with a default renderer");
617 DALI_TEST_CHECK(borderVisual);
619 DummyControl dummyControl = DummyControl::New(true);
620 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
621 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
622 application.GetScene().Add(dummyControl);
624 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
629 int UtcDaliVisualGetPropertyMap3(void)
631 ToolkitTestApplication application;
632 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
634 VisualFactory factory = VisualFactory::Get();
635 DALI_TEST_CHECK(factory);
637 Property::Map propertyMap;
638 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
640 Vector2 start(-1.f, -1.f);
641 Vector2 end(1.f, 1.f);
642 propertyMap.Insert("startPosition", start);
643 propertyMap.Insert("endPosition", end);
644 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
646 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
648 Property::Array stopColors;
649 stopColors.PushBack(Color::RED);
650 stopColors.PushBack(Color::GREEN);
651 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
653 float borderlineWidth = 4.0f;
654 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
655 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
656 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
658 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
660 Property::Map resultMap;
661 gradientVisual.CreatePropertyMap(resultMap);
663 // check the property values from the returned map from visual
664 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
665 DALI_TEST_CHECK(value);
666 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
668 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
669 DALI_TEST_CHECK(value);
670 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
672 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
673 DALI_TEST_CHECK(value);
674 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
676 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
677 DALI_TEST_CHECK(value);
678 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
680 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
681 DALI_TEST_CHECK(value);
682 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
684 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
685 DALI_TEST_CHECK(value);
686 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
688 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
689 DALI_TEST_CHECK(value);
690 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
692 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
693 DALI_TEST_CHECK(value);
694 Property::Array* offsetArray = value->GetArray();
695 DALI_TEST_CHECK(offsetArray->Count() == 2);
696 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
697 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
699 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
700 DALI_TEST_CHECK(value);
701 Property::Array* colorArray = value->GetArray();
702 DALI_TEST_CHECK(colorArray->Count() == 2);
703 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
704 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
709 int UtcDaliVisualGetPropertyMap4(void)
711 ToolkitTestApplication application;
712 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
714 VisualFactory factory = VisualFactory::Get();
715 DALI_TEST_CHECK(factory);
717 Property::Map propertyMap;
718 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
720 Vector2 center(100.f, 100.f);
721 float radius = 100.f;
722 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
723 propertyMap.Insert(GradientVisual::Property::CENTER, center);
724 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
725 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
727 Property::Array stopColors;
728 stopColors.PushBack(Color::RED);
729 stopColors.PushBack(Color::BLACK);
730 stopColors.PushBack(Color::GREEN);
731 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
733 float borderlineWidth = 8.0f;
734 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
735 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
736 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
738 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
739 DALI_TEST_CHECK(gradientVisual);
741 Property::Map resultMap;
742 gradientVisual.CreatePropertyMap(resultMap);
744 // check the property values from the returned map from visual
745 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
746 DALI_TEST_CHECK(value);
747 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
749 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
750 DALI_TEST_CHECK(value);
751 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
753 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
754 DALI_TEST_CHECK(value);
755 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
757 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
758 DALI_TEST_CHECK(value);
759 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
761 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
762 DALI_TEST_CHECK(value);
763 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
765 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
766 DALI_TEST_CHECK(value);
767 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
769 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
770 DALI_TEST_CHECK(value);
771 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
773 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
774 DALI_TEST_CHECK(value);
775 Property::Array* offsetArray = value->GetArray();
776 DALI_TEST_CHECK(offsetArray->Count() == 3);
777 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
778 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
779 // any stop value will be clamped to [0.0, 1.0];
780 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
782 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
783 DALI_TEST_CHECK(value);
784 Property::Array* colorArray = value->GetArray();
785 DALI_TEST_CHECK(colorArray->Count() == 3);
786 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
787 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
788 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
793 int UtcDaliVisualGetPropertyMap5(void)
795 ToolkitTestApplication application;
796 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
798 VisualFactory factory = VisualFactory::Get();
799 Property::Map propertyMap;
800 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
801 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
802 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
803 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
804 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
805 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
806 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
807 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
808 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
809 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
810 propertyMap.Insert("synchronousLoading", true);
812 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
813 DALI_TEST_CHECK(imageVisual);
815 Property::Map resultMap;
816 imageVisual.CreatePropertyMap(resultMap);
818 // check the property values from the returned map from visual
819 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
820 DALI_TEST_CHECK(value);
821 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
823 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
824 DALI_TEST_CHECK(value);
825 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
827 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
828 DALI_TEST_CHECK(value);
829 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
831 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
832 DALI_TEST_CHECK(value);
833 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
835 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
836 DALI_TEST_CHECK(value);
837 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
839 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
840 DALI_TEST_CHECK(value);
841 DALI_TEST_CHECK(value->Get<int>() == 20);
843 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
844 DALI_TEST_CHECK(value);
845 DALI_TEST_CHECK(value->Get<int>() == 30);
847 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
848 DALI_TEST_CHECK(value);
849 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
851 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
852 DALI_TEST_CHECK(value);
853 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
855 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
856 DALI_TEST_CHECK(value);
857 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
859 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
860 DALI_TEST_CHECK(value);
861 DALI_TEST_CHECK(value->Get<bool>() == true);
866 int UtcDaliVisualGetPropertyMap6(void)
868 ToolkitTestApplication application;
869 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
871 Rect<int> border(1, 1, 1, 1);
873 VisualFactory factory = VisualFactory::Get();
874 Property::Map propertyMap;
875 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
876 propertyMap.Insert("mixColor", Color::MAGENTA);
877 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
878 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
879 propertyMap.Insert(ImageVisual::Property::BORDER, border);
880 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
881 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
882 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
884 Property::Map resultMap;
885 nPatchVisual.CreatePropertyMap(resultMap);
887 // check the property values from the returned map from visual
888 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
889 DALI_TEST_CHECK(value);
890 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
892 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
893 DALI_TEST_CHECK(value);
894 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
896 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
897 DALI_TEST_CHECK(value);
898 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
900 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
901 DALI_TEST_CHECK(value);
902 DALI_TEST_CHECK(value->Get<bool>());
904 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
905 DALI_TEST_CHECK(value);
906 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
908 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
909 DALI_TEST_CHECK(value);
910 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
912 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
913 DALI_TEST_CHECK(value);
914 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
916 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
918 Property::Map propertyMap1;
919 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
920 propertyMap1.Insert("mixColor", Color::MAGENTA);
921 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
922 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
923 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
924 nPatchVisual = factory.CreateVisual(propertyMap1);
926 nPatchVisual.CreatePropertyMap(resultMap);
928 // check the property values from the returned map from visual
929 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
930 DALI_TEST_CHECK(value);
931 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
933 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
934 DALI_TEST_CHECK(value);
935 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
937 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
938 DALI_TEST_CHECK(value);
939 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
941 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
942 DALI_TEST_CHECK(value);
943 DALI_TEST_CHECK(value->Get<bool>());
945 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
946 DALI_TEST_CHECK(value);
947 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
952 int UtcDaliVisualGetPropertyMap7(void)
954 ToolkitTestApplication application;
955 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
957 // request SvgVisual with a property map
958 VisualFactory factory = VisualFactory::Get();
959 Property::Map propertyMap;
960 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
961 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
962 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
963 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
964 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
966 Property::Map resultMap;
967 svgVisual.CreatePropertyMap(resultMap);
968 // check the property values from the returned map from a visual
969 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
970 DALI_TEST_CHECK(value);
971 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
973 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
974 DALI_TEST_CHECK(value);
975 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
977 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
978 DALI_TEST_CHECK(value);
979 DALI_TEST_CHECK(value->Get<bool>() == false);
981 // request SvgVisual with a property map 2
983 propertyMap["visualType"] = Visual::SVG;
984 propertyMap["mixColor"] = Color::WHITE;
985 propertyMap["url"] = TEST_SVG_FILE_NAME;
986 propertyMap["atlasing"] = true;
987 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
990 svgVisual1.CreatePropertyMap(resultMap);
991 // check the property values from the returned map from a visual
992 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
993 DALI_TEST_CHECK(value);
994 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
996 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
997 DALI_TEST_CHECK(value);
998 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1000 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1001 DALI_TEST_CHECK(value);
1002 DALI_TEST_CHECK(value->Get<bool>() == true);
1004 // request SvgVisual with an URL
1005 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1007 svgVisual2.CreatePropertyMap(resultMap);
1008 // check the property values from the returned map from a visual
1009 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1010 DALI_TEST_CHECK(value);
1011 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1013 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1014 DALI_TEST_CHECK(value);
1015 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1021 int UtcDaliVisualGetPropertyMap8(void)
1023 ToolkitTestApplication application;
1024 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1026 //Request MeshVisual using a property map.
1027 VisualFactory factory = VisualFactory::Get();
1028 Property::Map propertyMap;
1029 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1030 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1031 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1032 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1033 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1034 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1035 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1036 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1038 Property::Map resultMap;
1039 meshVisual.CreatePropertyMap(resultMap);
1040 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1042 //Check values in the result map are identical to the initial map's values.
1043 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1044 DALI_TEST_CHECK(value);
1045 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1047 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1048 DALI_TEST_CHECK(value);
1049 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1051 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1052 DALI_TEST_CHECK(value);
1053 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1055 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1056 DALI_TEST_CHECK(value);
1057 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1059 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1060 DALI_TEST_CHECK(value);
1061 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1063 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1064 DALI_TEST_CHECK(value);
1065 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1070 //Primitive shape visual
1071 int UtcDaliVisualGetPropertyMap9(void)
1073 ToolkitTestApplication application;
1074 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1076 static std::vector<UniformData> customUniforms =
1078 UniformData("mixColor", Property::Type::VECTOR3),
1081 TestGraphicsController& graphics = application.GetGraphicsController();
1082 graphics.AddCustomUniforms(customUniforms);
1084 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1085 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1087 //Request PrimitiveVisual using a property map.
1088 VisualFactory factory = VisualFactory::Get();
1089 Property::Map propertyMap;
1090 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1091 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1092 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1093 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1094 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1095 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1096 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1097 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1098 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1099 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1100 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1101 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1102 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1103 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1105 Property::Map resultMap;
1106 primitiveVisual.CreatePropertyMap(resultMap);
1108 //Check values in the result map are identical to the initial map's values.
1109 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1110 DALI_TEST_CHECK(value);
1111 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1113 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1114 DALI_TEST_CHECK(value);
1115 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1117 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1118 DALI_TEST_CHECK(value);
1119 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1120 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1122 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1123 DALI_TEST_CHECK(value);
1124 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1126 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1127 DALI_TEST_CHECK(value);
1128 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1130 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1131 DALI_TEST_CHECK(value);
1132 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1134 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1135 DALI_TEST_CHECK(value);
1136 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1138 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1139 DALI_TEST_CHECK(value);
1140 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1142 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1143 DALI_TEST_CHECK(value);
1144 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1146 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1147 DALI_TEST_CHECK(value);
1148 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1150 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1151 DALI_TEST_CHECK(value);
1152 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1154 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1155 DALI_TEST_CHECK(value);
1156 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1158 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1159 DALI_TEST_CHECK(value);
1160 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1162 DummyControl actor = DummyControl::New(true);
1163 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1164 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1165 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1166 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1167 application.GetScene().Add(actor);
1169 Animation animation = Animation::New(1.0f);
1170 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1172 application.SendNotification();
1173 application.Render(0);
1174 application.Render(1000);
1175 application.SendNotification();
1177 auto& gl = application.GetGlAbstraction();
1178 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1180 tet_infoline("Check property map after animation");
1182 primitiveVisual.CreatePropertyMap(resultMap);
1183 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1184 DALI_TEST_CHECK(value);
1185 color = value->Get<Vector4>();
1186 // Ignore alpha part
1187 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1193 int UtcDaliVisualGetPropertyMap10(void)
1195 ToolkitTestApplication application;
1196 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1198 //Request PrimitiveVisual using a property map.
1199 VisualFactory factory = VisualFactory::Get();
1201 Property::Map propertyMap;
1202 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1203 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1204 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1205 propertyMap.Insert("enableMarkup", false);
1206 propertyMap.Insert("text", "Hello world");
1207 propertyMap.Insert("fontFamily", "TizenSans");
1209 Property::Map fontStyleMapSet;
1210 fontStyleMapSet.Insert("weight", "bold");
1211 propertyMap.Insert("fontStyle", fontStyleMapSet);
1213 propertyMap.Insert("pointSize", 12.f);
1214 propertyMap.Insert("multiLine", true);
1215 propertyMap.Insert("horizontalAlignment", "CENTER");
1216 propertyMap.Insert("verticalAlignment", "CENTER");
1217 propertyMap.Insert("textColor", Color::RED);
1219 Property::Map shadowMapSet;
1220 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1222 Property::Map underlineMapSet;
1223 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));
1225 Property::Map outlineMapSet;
1226 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1228 Property::Map backgroundMapSet;
1229 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1231 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1233 Property::Map resultMap;
1234 textVisual.CreatePropertyMap(resultMap);
1236 //Check values in the result map are identical to the initial map's values.
1237 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1238 DALI_TEST_CHECK(value);
1239 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1241 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1242 DALI_TEST_CHECK(value);
1243 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1245 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1246 DALI_TEST_CHECK(value);
1247 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1249 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1250 DALI_TEST_CHECK(value);
1251 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1253 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1254 DALI_TEST_CHECK(value);
1256 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1257 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1258 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1260 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1261 DALI_TEST_CHECK(value);
1262 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1264 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1265 DALI_TEST_CHECK(value);
1266 DALI_TEST_CHECK(value->Get<bool>());
1268 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1269 DALI_TEST_CHECK(value);
1270 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1272 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1273 DALI_TEST_CHECK(value);
1274 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1276 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1277 DALI_TEST_CHECK(value);
1278 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1280 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1281 DALI_TEST_CHECK(value);
1282 DALI_TEST_CHECK(!value->Get<bool>());
1284 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1285 DALI_TEST_CHECK(value);
1287 Property::Map shadowMapGet = value->Get<Property::Map>();
1288 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1289 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1291 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1292 DALI_TEST_CHECK(value);
1294 Property::Map underlineMapGet = value->Get<Property::Map>();
1295 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1296 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1298 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1299 DALI_TEST_CHECK(value);
1301 Property::Map outlineMapGet = value->Get<Property::Map>();
1302 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1303 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1305 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1306 DALI_TEST_CHECK(value);
1308 Property::Map backgroundMapGet = value->Get<Property::Map>();
1309 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1310 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1315 int UtcDaliVisualGetPropertyMap11(void)
1317 ToolkitTestApplication application;
1318 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1320 VisualFactory factory = VisualFactory::Get();
1321 DALI_TEST_CHECK(factory);
1323 Property::Map propertyMap;
1324 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1326 Vector2 start(-0.5f, 0.5f);
1327 Vector2 end(0.5f, -0.0f);
1328 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1329 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1330 Vector2 rotate_center(0.0f, 0.4f);
1331 float rotate_amount = 1.57f;
1332 float offset = 100.f;
1334 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1335 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1336 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1338 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1339 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1340 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1341 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1342 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1343 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1344 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1346 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1347 DALI_TEST_CHECK(animatedGradientVisual);
1349 Property::Map resultMap;
1350 animatedGradientVisual.CreatePropertyMap(resultMap);
1352 // check the property values from the returned map from visual
1353 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1354 DALI_TEST_CHECK(value);
1355 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1357 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1358 DALI_TEST_CHECK(value);
1359 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1361 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1362 DALI_TEST_CHECK(value);
1363 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1365 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1366 DALI_TEST_CHECK(value);
1367 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1369 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1370 DALI_TEST_CHECK(value);
1371 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1373 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1374 DALI_TEST_CHECK(value);
1375 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1377 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1378 DALI_TEST_CHECK(value);
1379 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1381 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1382 DALI_TEST_CHECK(value);
1383 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1385 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1386 DALI_TEST_CHECK(value);
1387 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1389 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1390 DALI_TEST_CHECK(value);
1391 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1393 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1394 DALI_TEST_CHECK(value);
1395 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1400 int UtcDaliVisualGetPropertyMap12(void)
1402 ToolkitTestApplication application;
1403 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1405 // Case 1 : Set values by index
1407 tet_printf(" - Set Values by Index\n");
1408 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1409 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1410 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1412 tet_printf("test with delay [%f]\n", _delay);
1413 VisualFactory factory = VisualFactory::Get();
1414 DALI_TEST_CHECK(factory);
1416 Property::Map propertyMap;
1417 Property::Map animationMap;
1418 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1420 float duration = 1.1f;
1421 float delay = _delay;
1422 float repeat_delay = 0.4f;
1424 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1426 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1427 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1429 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1430 animationMap.Clear();
1431 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1432 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1433 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1434 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1435 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1436 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1437 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1438 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1439 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1441 return animationMap;
1444 Vector2 start1(-0.5f, 0.5f);
1445 Vector2 end1(0.5f, -0.5f);
1446 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1447 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1448 Vector2 rotate_center1(0.0f, 0.4f);
1449 float rotate_amount1 = 0.0f;
1450 float offset1 = 0.f;
1452 Vector2 start2(-0.5f, -0.5f);
1453 Vector2 end2(0.5f, 0.5f);
1454 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1455 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1456 Vector2 rotate_center2(0.0f, -0.4f);
1457 float rotate_amount2 = 6.2832f;
1458 float offset2 = 2.f;
1460 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1461 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1462 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1464 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1465 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1466 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1467 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1468 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1469 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1470 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1472 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1473 DALI_TEST_CHECK(animatedGradientVisual);
1475 Property::Map resultMap;
1476 animatedGradientVisual.CreatePropertyMap(resultMap);
1478 // check the property values from the returned map from visual
1479 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1480 DALI_TEST_CHECK(value);
1481 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1483 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1484 DALI_TEST_CHECK(value);
1485 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1487 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1488 DALI_TEST_CHECK(value);
1489 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1491 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1492 DALI_TEST_CHECK(value);
1493 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1495 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 {
1496 tet_printf("Check value at %d\n", line_num);
1497 value = resultMap.Find(index, Property::MAP);
1498 DALI_TEST_CHECK(value);
1499 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1500 Property::Map* temp_map = value->GetMap();
1501 DALI_TEST_CHECK(temp_map);
1503 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1504 Property::Value* res = temp_map->Find(index);
1505 DALI_TEST_CHECK(res);
1509 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1510 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1511 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1512 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1513 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1514 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1515 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1516 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1517 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1520 // check the animation map data is good
1521 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1522 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1523 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1524 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1525 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1526 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1527 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1531 // Case 2 : Set values by string
1533 tet_printf(" - Set Values by String\n");
1534 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1535 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1536 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1538 tet_printf("test with delay [%f]\n", _delay);
1539 VisualFactory factory = VisualFactory::Get();
1540 DALI_TEST_CHECK(factory);
1542 Property::Map propertyMap;
1543 Property::Map animationMap;
1544 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1546 float duration = 1.1f;
1547 float delay = _delay;
1548 float repeat_delay = 0.4f;
1550 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1552 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1553 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1555 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1556 animationMap.Clear();
1557 animationMap.Insert("startValue", start);
1558 animationMap.Insert("targetValue", target);
1559 animationMap.Insert("directionType", "BACKWARD");
1560 animationMap.Insert("duration", duration);
1561 animationMap.Insert("delay", delay);
1562 animationMap.Insert("repeat", loop_count);
1563 animationMap.Insert("repeatDelay", repeat_delay);
1564 animationMap.Insert("motionType", "MIRROR");
1565 animationMap.Insert("easingType", "IN_OUT");
1567 return animationMap;
1570 Vector2 start1(-0.5f, 0.5f);
1571 Vector2 end1(0.5f, -0.5f);
1572 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1573 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1574 Vector2 rotate_center1(0.0f, 0.4f);
1575 float rotate_amount1 = 0.0f;
1576 float offset1 = 0.f;
1578 Vector2 start2(-0.5f, -0.5f);
1579 Vector2 end2(0.5f, 0.5f);
1580 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1581 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1582 Vector2 rotate_center2(0.0f, -0.4f);
1583 float rotate_amount2 = 6.2832f;
1584 float offset2 = 2.f;
1586 // For test mix the type string/index key and string/index value works well.
1587 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1588 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1589 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1591 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1592 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1593 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1594 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1595 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1596 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1597 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1599 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1600 DALI_TEST_CHECK(animatedGradientVisual);
1602 Property::Map resultMap;
1603 animatedGradientVisual.CreatePropertyMap(resultMap);
1605 // check the property values from the returned map from visual
1606 // Note : resultMap from CreatePropertyMap only contain indexKey
1607 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1608 DALI_TEST_CHECK(value);
1609 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1611 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1612 DALI_TEST_CHECK(value);
1613 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1615 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1616 DALI_TEST_CHECK(value);
1617 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1619 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1620 DALI_TEST_CHECK(value);
1621 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1623 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 {
1624 tet_printf("Check value at %d\n", line_num);
1625 value = resultMap.Find(index, Property::MAP);
1626 DALI_TEST_CHECK(value);
1627 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1628 Property::Map* temp_map = value->GetMap();
1629 DALI_TEST_CHECK(temp_map);
1631 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1632 Property::Value* res = temp_map->Find(index);
1633 DALI_TEST_CHECK(res);
1637 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1638 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1639 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1640 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1641 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1642 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1643 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1644 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1645 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1648 // check the animation map data is good
1649 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1650 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1651 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1652 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1653 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1654 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1655 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1661 int UtcDaliVisualGetPropertyMap13(void)
1663 ToolkitTestApplication application;
1664 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1666 for(int _direction = 0; _direction <= 1; ++_direction)
1668 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1670 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1671 VisualFactory factory = VisualFactory::Get();
1672 DALI_TEST_CHECK(factory);
1674 Property::Map propertyMap;
1675 Property::Map animationMap;
1676 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1678 float duration = 1.0f;
1679 float delay = _delay;
1680 float repeat_delay = 0.5f;
1682 int direction = _direction;
1683 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1684 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1685 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1687 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1688 animationMap.Clear();
1689 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1690 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1692 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1694 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1695 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1696 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1697 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1698 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1699 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1700 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1701 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1703 return animationMap;
1706 Vector2 start1(-0.5f, 0.5f);
1707 Vector2 end1(0.5f, -0.5f);
1708 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1709 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1710 Vector2 rotate_center1(1.0f, 0.4f);
1711 float rotate_amount1 = 2.0f;
1712 float offset1 = 1.f;
1714 Vector2 start2(-0.5f, -0.5f);
1715 Vector2 end2(0.5f, 0.5f);
1716 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1717 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1718 Vector2 rotate_center2(1.0f, -0.4f);
1719 float rotate_amount2 = 1.0f;
1720 float offset2 = 3.f;
1722 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1723 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1724 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1726 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1727 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1728 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1729 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1730 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1731 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1732 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1734 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1735 DALI_TEST_CHECK(animatedGradientVisual);
1737 Property::Map resultMap;
1738 animatedGradientVisual.CreatePropertyMap(resultMap);
1740 // check the property values from the returned map from visual
1741 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1742 DALI_TEST_CHECK(value);
1743 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1745 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1746 DALI_TEST_CHECK(value);
1747 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1749 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1750 DALI_TEST_CHECK(value);
1751 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1753 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1754 DALI_TEST_CHECK(value);
1755 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1757 // If loop_count = 0, Animation doesn't created.
1758 // Optimized resultMap only have one value, which is target value
1759 // Note: target value will be changed by direction option.
1760 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1761 DALI_TEST_CHECK(value);
1762 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1764 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1765 DALI_TEST_CHECK(value);
1766 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1768 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1769 DALI_TEST_CHECK(value);
1770 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1772 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1773 DALI_TEST_CHECK(value);
1774 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1776 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1777 DALI_TEST_CHECK(value);
1778 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1780 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1781 DALI_TEST_CHECK(value);
1782 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1784 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1785 DALI_TEST_CHECK(value);
1786 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1793 int UtcDaliVisualAnimateBorderVisual01(void)
1795 ToolkitTestApplication application;
1796 tet_infoline("UtcDaliAnimateBorderVisual Color");
1798 static std::vector<UniformData> customUniforms =
1800 UniformData("borderColor", Property::Type::VECTOR4),
1801 UniformData("mixColor", Property::Type::VECTOR3),
1804 TestGraphicsController& graphics = application.GetGraphicsController();
1805 graphics.AddCustomUniforms(customUniforms);
1807 VisualFactory factory = VisualFactory::Get();
1808 Property::Map propertyMap;
1809 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1810 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1811 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1812 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1813 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1816 map["target"] = "testVisual";
1817 map["property"] = "mixColor";
1818 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1819 map["animator"] = Property::Map()
1820 .Add("alphaFunction", "LINEAR")
1821 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1823 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1825 DummyControl actor = DummyControl::New(true);
1826 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1827 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1828 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1829 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1830 application.GetScene().Add(actor);
1832 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1834 Renderer renderer = actor.GetRendererAt(0);
1835 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1836 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1838 Animation animation = dummyImpl.CreateTransition(transition);
1840 // Animate the mix color through the transition, and the border color through
1841 // programmatic method.
1842 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1845 application.SendNotification();
1846 application.Render(0);
1847 application.Render(2000u); // halfway point between blue and white
1849 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1850 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1851 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1852 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1854 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1855 testColor = Vector4(1, 1, 1, 0.45f);
1856 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1857 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1860 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1861 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1863 application.Render(2000u);
1865 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1866 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1867 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1869 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1870 testColor = Vector4(1, 1, 1, 0.1);
1871 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1872 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1874 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1875 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1880 int UtcDaliVisualAnimateBorderVisual02(void)
1882 ToolkitTestApplication application;
1883 tet_infoline("UtcDaliAnimateBorderVisual Size");
1885 static std::vector<UniformData> customUniforms =
1887 UniformData("borderSize", Property::Type::FLOAT),
1890 TestGraphicsController& graphics = application.GetGraphicsController();
1891 graphics.AddCustomUniforms(customUniforms);
1893 VisualFactory factory = VisualFactory::Get();
1894 Property::Map propertyMap;
1895 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1896 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1897 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1898 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1900 DummyControl actor = DummyControl::New(true);
1901 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1902 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1903 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1904 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1905 application.GetScene().Add(actor);
1907 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1909 Renderer renderer = actor.GetRendererAt(0);
1910 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1912 Animation animation = Animation::New(4.0f);
1913 animation.AnimateTo(Property(renderer, index), 9.0f);
1916 application.SendNotification();
1917 application.Render(0);
1918 application.Render(2000u); // halfway point
1920 float size = renderer.GetCurrentProperty<float>(index);
1921 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1922 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1924 application.Render(2000u); // halfway point between blue and white
1926 size = renderer.GetCurrentProperty<float>(index);
1927 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1928 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1933 int UtcDaliVisualAnimateColorVisual(void)
1935 ToolkitTestApplication application;
1936 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1938 static std::vector<UniformData> customUniforms =
1940 UniformData("mixColor", Property::Type::VECTOR3),
1943 TestGraphicsController& graphics = application.GetGraphicsController();
1944 graphics.AddCustomUniforms(customUniforms);
1946 VisualFactory factory = VisualFactory::Get();
1947 Property::Map propertyMap;
1948 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1949 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1950 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1952 DummyControl actor = DummyControl::New(true);
1953 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1954 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1955 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1956 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1957 application.GetScene().Add(actor);
1959 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1961 Renderer renderer = actor.GetRendererAt(0);
1962 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1964 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1965 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1967 Animation animation = Animation::New(4.0f);
1968 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1971 application.SendNotification();
1972 application.Render(0);
1973 application.Render(2000u); // halfway point
1975 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1976 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
1977 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1979 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1981 application.Render(2000u); // halfway point between blue and white
1983 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1984 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
1986 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
1988 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
1989 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1994 int UtcDaliVisualAnimatePrimitiveVisual(void)
1996 ToolkitTestApplication application;
1997 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
1999 static std::vector<UniformData> customUniforms =
2001 UniformData("mixColor", Property::Type::VECTOR3),
2004 TestGraphicsController& graphics = application.GetGraphicsController();
2005 graphics.AddCustomUniforms(customUniforms);
2008 VisualFactory factory = VisualFactory::Get();
2009 Property::Map propertyMap;
2010 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2011 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2012 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2013 Visual::Base visual = factory.CreateVisual(propertyMap);
2015 DummyControl actor = DummyControl::New(true);
2016 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2017 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2018 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2019 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2020 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2021 application.GetScene().Add(actor);
2023 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2025 Renderer renderer = actor.GetRendererAt(0);
2027 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2028 const Vector4 TARGET_MIX_COLOR(Color::RED);
2031 map["target"] = "testVisual";
2032 map["property"] = "mixColor";
2033 map["initialValue"] = INITIAL_MIX_COLOR;
2034 map["targetValue"] = TARGET_MIX_COLOR;
2035 map["animator"] = Property::Map()
2036 .Add("alphaFunction", "LINEAR")
2037 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2039 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2041 Animation animation = dummyImpl.CreateTransition(transition);
2042 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2045 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2046 glAbstraction.EnableEnableDisableCallTrace(true);
2047 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2048 std::ostringstream blendStr;
2049 blendStr << std::hex << GL_BLEND;
2051 application.SendNotification();
2052 application.Render(0);
2053 application.Render(2000u); // halfway point
2054 application.SendNotification();
2056 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2057 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2058 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2060 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2062 glEnableStack.Reset();
2064 application.Render(2001u); // go past end
2065 application.SendNotification(); // Trigger signals
2067 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2068 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2069 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2071 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2079 int UtcDaliVisualAnimatedGradientVisual01(void)
2081 ToolkitTestApplication application;
2082 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2084 static std::vector<UniformData> customUniforms =
2086 UniformData("start_point", Property::Type::VECTOR2),
2087 UniformData("end_point", Property::Type::VECTOR2),
2088 UniformData("start_color", Property::Type::VECTOR4),
2089 UniformData("end_color", Property::Type::VECTOR4),
2090 UniformData("rotate_center", Property::Type::VECTOR2),
2091 UniformData("rotate_angle", Property::Type::FLOAT),
2092 UniformData("gradient_offset", Property::Type::FLOAT),
2095 TestGraphicsController& graphics = application.GetGraphicsController();
2096 graphics.AddCustomUniforms(customUniforms);
2099 VisualFactory factory = VisualFactory::Get();
2100 Property::Map propertyMap;
2101 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2102 Visual::Base visual = factory.CreateVisual(propertyMap);
2104 DummyControl actor = DummyControl::New(true);
2105 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2106 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2107 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2108 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2109 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2110 application.GetScene().Add(actor);
2112 application.SendNotification();
2113 application.Render(0);
2114 application.SendNotification();
2116 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2118 for(int step_iter = 0; step_iter < 3; step_iter++)
2120 application.SendNotification();
2121 application.Render(0);
2122 application.Render(750u); // step i/4
2123 application.SendNotification();
2125 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2126 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2127 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2128 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2129 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2130 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2131 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2134 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2135 application.Render(750u); // go to end
2136 application.SendNotification();
2138 application.Render(10u); // finish
2139 application.SendNotification();
2142 application.SendNotification();
2143 application.Render(0u);
2144 application.SendNotification();
2150 int UtcDaliVisualAnimatedGradientVisual02(void)
2152 ToolkitTestApplication application;
2153 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2155 static std::vector<UniformData> customUniforms =
2157 UniformData("start_point", Property::Type::VECTOR2),
2158 UniformData("end_point", Property::Type::VECTOR2),
2159 UniformData("start_color", Property::Type::VECTOR4),
2160 UniformData("end_color", Property::Type::VECTOR4),
2161 UniformData("rotate_center", Property::Type::VECTOR2),
2162 UniformData("rotate_angle", Property::Type::FLOAT),
2163 UniformData("gradient_offset", Property::Type::FLOAT),
2166 TestGraphicsController& graphics = application.GetGraphicsController();
2167 graphics.AddCustomUniforms(customUniforms);
2170 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
2171 int _direction[2] = {0, 1};
2172 int _loop_count[3] = {-1, 0, 1};
2173 int _motion[2] = {0, 1};
2174 int _easing[4] = {0, 1, 2, 3};
2176 int test_case_max = 4 * 2 * 3 * 2 * 4;
2178 int test_case_d = 7; // 7 is the number of animated properties.
2180 float _duration = 0.4f;
2181 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2182 float noise_maker = 0.0f;
2183 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2184 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2186 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2188 VisualFactory factory = VisualFactory::Get();
2189 Property::Map propertyMap;
2190 Property::Map animationMap;
2191 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2193 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2194 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2195 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2197 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& {
2198 int tc = (test_case + tc_offset);
2199 int idx_easing = tc % 4;
2201 int idx_motion = tc % 2;
2203 int idx_loop_count = tc % 3;
2205 int idx_direction = tc % 2;
2207 int idx_delay = tc % 4;
2210 float duration = _duration - _repeat_delay;
2211 float repeat_delay = _repeat_delay;
2212 float delay = _delay[idx_delay] * _duration;
2213 int direction = _direction[idx_direction];
2214 int loop_count = _loop_count[idx_loop_count];
2215 int motion = _motion[idx_motion];
2216 int easing = _easing[idx_easing];
2218 animationMap.Clear();
2219 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2220 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2223 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2227 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2229 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2230 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2231 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2232 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2235 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2239 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2243 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2245 else if(easing == 1)
2247 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2249 else if(easing == 2)
2251 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2255 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2258 return animationMap;
2261 // Give different values for debuging
2262 noise_maker += 1.0f;
2263 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2264 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2265 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2266 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2267 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2268 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2269 float offset1 = 0.f + noise_maker * 0.1f;
2271 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2272 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2273 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2274 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2275 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2276 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2277 float offset2 = 2.f + noise_maker * 0.1f;
2279 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2280 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2281 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2283 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2284 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2285 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2286 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2287 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2288 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2289 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2291 Visual::Base visual = factory.CreateVisual(propertyMap);
2293 DummyControl actor = DummyControl::New(true);
2294 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2295 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2296 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2297 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2298 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2299 application.GetScene().Add(actor);
2301 application.SendNotification();
2302 application.Render(0);
2303 application.SendNotification();
2305 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2307 application.SendNotification();
2309 //Compare between CPU calculated value and Shader Visual calculated value
2310 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 {
2311 int tc = (test_case + tc_offset);
2312 int idx_easing = tc % 4;
2314 int idx_motion = tc % 2;
2316 int idx_loop_count = tc % 3;
2318 int idx_direction = tc % 2;
2320 int idx_delay = tc % 4;
2323 float duration = _duration - _repeat_delay;
2324 float repeat_delay = _repeat_delay;
2325 float delay = _delay[idx_delay] * _duration;
2326 int direction = _direction[idx_direction];
2327 int loop_count = _loop_count[idx_loop_count];
2328 int motion = _motion[idx_motion];
2329 int easing = _easing[idx_easing];
2331 progress -= delay / _duration;
2333 Property::Value s = start;
2334 Property::Value t = target;
2340 float x; ///< Animator progress value
2345 else if(loop_count > 0 && progress + 0.01f > loop_count)
2347 x = (motion == 0) ? 1.0f : 0.0f;
2355 progress = fmodf(progress, 1.0f);
2356 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2361 x = progress * 2.0f;
2368 if(easing == 1) // EASE_IN
2372 else if(easing == 2) // EASE_OUT
2374 x = 2.0f * x - x * x;
2376 else if(easing == 3) // EASE_IN_OUT
2378 x = x * x * (3.0f - 2.0f * x);
2381 if(value_type == 0) // result type is Float
2385 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2386 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2387 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2389 else if(value_type == 1) // result type is Vector2
2393 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2394 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2395 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2397 else if(value_type == 2) // result type is Vector3
2401 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2402 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2403 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2405 else // result type is Vector4
2409 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2410 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2411 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2416 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2418 for(int step_iter = 0; step_iter < 3; step_iter++)
2420 application.SendNotification();
2421 application.Render(_duration * 250.f); // step i/4
2422 application.SendNotification();
2425 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2426 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2427 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2428 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2429 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2430 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2431 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2433 application.SendNotification();
2434 application.Render(_duration * 250.f); // step 4/4 will not test
2435 application.SendNotification();
2439 application.SendNotification();
2441 application.SendNotification();
2442 application.Render(10.f); // tempral time
2443 application.SendNotification();
2450 int UtcDaliVisualAnimatedGradientVisual03(void)
2452 ToolkitTestApplication application;
2453 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2455 static std::vector<UniformData> customUniforms =
2457 UniformData("start_point", Property::Type::VECTOR2),
2458 UniformData("end_point", Property::Type::VECTOR2),
2459 UniformData("start_color", Property::Type::VECTOR4),
2460 UniformData("end_color", Property::Type::VECTOR4),
2461 UniformData("rotate_center", Property::Type::VECTOR2),
2462 UniformData("rotate_angle", Property::Type::FLOAT),
2463 UniformData("gradient_offset", Property::Type::FLOAT),
2466 TestGraphicsController& graphics = application.GetGraphicsController();
2467 graphics.AddCustomUniforms(customUniforms);
2470 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
2471 int _direction[2] = {0, 1};
2472 int _loop_count[3] = {-1, 0, 1};
2473 int _motion[2] = {0, 1};
2474 int _easing[4] = {0, 1, 2, 3};
2476 int test_case_max = 4 * 2 * 3 * 2 * 4;
2478 int test_case_d = 7; // 7 is the number of animated properties.
2480 float _duration = 0.4f;
2481 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2482 float noise_maker = 0.2f;
2483 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2484 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2486 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2488 VisualFactory factory = VisualFactory::Get();
2489 Property::Map propertyMap;
2490 Property::Map animationMap;
2491 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2493 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& {
2494 int tc = (test_case + tc_offset);
2495 int idx_easing = tc % 4;
2497 int idx_motion = tc % 2;
2499 int idx_loop_count = tc % 3;
2501 int idx_direction = tc % 2;
2503 int idx_delay = tc % 4;
2506 float duration = _duration - _repeat_delay;
2507 float repeat_delay = _repeat_delay;
2508 float delay = _delay[idx_delay] * _duration;
2509 int direction = _direction[idx_direction];
2510 int loop_count = _loop_count[idx_loop_count];
2511 int motion = _motion[idx_motion];
2512 int easing = _easing[idx_easing];
2514 animationMap.Clear();
2515 animationMap.Insert("startValue", start);
2516 animationMap.Insert("targetValue", target);
2519 animationMap.Insert("directionType", "FORWARD");
2523 animationMap.Insert("directionType", "BACKWARD");
2525 animationMap.Insert("duration", duration);
2526 animationMap.Insert("delay", delay);
2527 animationMap.Insert("repeat", loop_count);
2528 animationMap.Insert("repeatDelay", repeat_delay);
2531 animationMap.Insert("motionType", "LOOP");
2535 animationMap.Insert("motionType", "MIRROR");
2539 animationMap.Insert("easingType", "LINEAR");
2541 else if(easing == 1)
2543 animationMap.Insert("easingType", "IN");
2545 else if(easing == 2)
2547 animationMap.Insert("easingType", "OUT");
2551 animationMap.Insert("easingType", "IN_OUT");
2554 return animationMap;
2557 // Give different values for debuging
2558 noise_maker += 0.8f;
2559 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2560 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2561 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2562 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2563 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2564 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2565 float offset1 = 0.f + noise_maker * 0.1f;
2567 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2568 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2569 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2570 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2571 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2572 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2573 float offset2 = 2.f + noise_maker * 0.1f;
2575 propertyMap.Insert("gradientType", "LINEAR");
2576 propertyMap.Insert("unitType", "USER_SPACE");
2577 propertyMap.Insert("spreadType", "CLAMP");
2579 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2580 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2581 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2582 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2583 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2584 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2585 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2587 Visual::Base visual = factory.CreateVisual(propertyMap);
2589 DummyControl actor = DummyControl::New(true);
2590 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2591 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2592 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2593 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2594 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2595 application.GetScene().Add(actor);
2597 application.SendNotification();
2598 application.Render(0);
2599 application.SendNotification();
2601 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2603 application.SendNotification();
2605 //Compare between CPU calculated value and Shader Visual calculated value
2606 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 {
2607 int tc = (test_case + tc_offset);
2608 int idx_easing = tc % 4;
2610 int idx_motion = tc % 2;
2612 int idx_loop_count = tc % 3;
2614 int idx_direction = tc % 2;
2616 int idx_delay = tc % 4;
2619 float duration = _duration - _repeat_delay;
2620 float repeat_delay = _repeat_delay;
2621 float delay = _delay[idx_delay] * _duration;
2622 int direction = _direction[idx_direction];
2623 int loop_count = _loop_count[idx_loop_count];
2624 int motion = _motion[idx_motion];
2625 int easing = _easing[idx_easing];
2627 progress -= delay / _duration;
2629 Property::Value s = start;
2630 Property::Value t = target;
2636 float x; ///< Animator progress value
2641 else if(loop_count > 0 && progress + 0.01f > loop_count)
2643 x = (motion == 0) ? 1.0f : 0.0f;
2651 progress = fmodf(progress, 1.0f);
2652 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2657 x = progress * 2.0f;
2664 if(easing == 1) // EASE_IN
2668 else if(easing == 2) // EASE_OUT
2670 x = 2.0f * x - x * x;
2672 else if(easing == 3) // EASE_IN_OUT
2674 x = x * x * (3.0f - 2.0f * x);
2677 if(value_type == 0) // result type is Float
2681 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2682 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2683 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2685 else if(value_type == 1) // result type is Vector2
2689 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2690 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2691 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2693 else if(value_type == 2) // result type is Vector3
2697 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2698 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2699 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2701 else // result type is Vector4
2705 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2706 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2707 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2712 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2714 for(int step_iter = 0; step_iter < 3; step_iter++)
2716 application.SendNotification();
2717 application.Render(_duration * 250.f); // step i/4
2718 application.SendNotification();
2721 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2722 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2723 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2724 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2725 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2726 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2727 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2729 application.SendNotification();
2730 application.Render(_duration * 250.f); // step 4/4 will not test
2731 application.SendNotification();
2735 application.SendNotification();
2737 application.SendNotification();
2738 application.Render(10.f); // tempral time
2739 application.SendNotification();
2746 int UtcDaliVisualWireframeVisual(void)
2748 ToolkitTestApplication application;
2750 VisualFactory factory = VisualFactory::Get();
2751 Property::Map propertyMap;
2752 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2754 // Create the visual.
2755 Visual::Base visual = factory.CreateVisual(propertyMap);
2757 DALI_TEST_CHECK(visual);
2759 Property::Map resultMap;
2760 visual.CreatePropertyMap(resultMap);
2762 // Check the property values from the returned map from visual
2763 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2764 DALI_TEST_CHECK(value);
2765 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2770 int UtcDaliVisualGetTransform(void)
2772 ToolkitTestApplication application;
2773 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2775 VisualFactory factory = VisualFactory::Get();
2776 Property::Map propertyMap;
2777 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2778 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2779 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2781 Dali::Property::Map visualMap;
2782 colorVisual.CreatePropertyMap(visualMap);
2783 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2784 Dali::Property::Map* map = value->GetMap();
2785 DALI_TEST_CHECK(map);
2787 //Test default values
2789 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2790 DALI_TEST_CHECK(typeValue);
2791 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2794 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2795 DALI_TEST_CHECK(typeValue);
2796 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2799 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2800 DALI_TEST_CHECK(typeValue);
2801 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2804 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2805 DALI_TEST_CHECK(typeValue);
2806 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2809 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2810 DALI_TEST_CHECK(typeValue);
2811 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2814 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2815 DALI_TEST_CHECK(typeValue);
2816 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2819 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2820 DALI_TEST_CHECK(typeValue);
2821 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2827 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2829 Property::Map transform;
2830 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2831 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2832 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2833 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2834 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2835 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2837 visual.SetTransformAndSize(transform, Vector2(100, 100));
2839 Dali::Property::Map visualMap;
2840 visual.CreatePropertyMap(visualMap);
2841 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2842 Dali::Property::Map* map = value->GetMap();
2843 DALI_TEST_CHECK(map);
2846 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2847 DALI_TEST_CHECK(typeValue);
2848 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2851 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2852 DALI_TEST_CHECK(typeValue);
2853 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2856 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2857 DALI_TEST_CHECK(typeValue);
2858 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2861 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2862 DALI_TEST_CHECK(typeValue);
2863 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2866 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2867 DALI_TEST_CHECK(typeValue);
2868 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2871 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2872 DALI_TEST_CHECK(typeValue);
2873 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2876 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2877 DALI_TEST_CHECK(typeValue);
2878 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2881 //Put the visual on the stage
2882 DummyControl actor = DummyControl::New(true);
2883 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2884 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2885 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2886 application.GetScene().Add(actor);
2888 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2889 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2891 application.SendNotification();
2892 application.Render(0);
2893 Renderer renderer(actor.GetRendererAt(0));
2895 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2896 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2898 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2899 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2901 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2902 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2904 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2905 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2907 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2908 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2910 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2911 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2913 //Set a new transform
2915 transform = DefaultTransform();
2916 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2917 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2918 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2919 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2920 visual.SetTransformAndSize(transform, Vector2(100, 100));
2921 application.SendNotification();
2922 application.Render(0);
2924 //Check that the values have changed in the renderer
2925 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2926 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2928 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2929 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2931 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2932 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2934 //Parent origin and anchor point should have the default values
2935 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2936 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2938 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2939 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2941 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2942 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2945 int UtcDaliVisualSetTransform01(void)
2947 ToolkitTestApplication application;
2948 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2950 VisualFactory factory = VisualFactory::Get();
2951 Property::Map propertyMap;
2952 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2953 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2954 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2955 Visual::Base visual = factory.CreateVisual(propertyMap);
2956 TestTransform(application, visual);
2957 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2962 int UtcDaliVisualSetTransform0(void)
2964 ToolkitTestApplication application;
2965 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2967 VisualFactory factory = VisualFactory::Get();
2968 Property::Map propertyMap;
2969 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2970 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2971 Visual::Base visual = factory.CreateVisual(propertyMap);
2972 TestTransform(application, visual);
2973 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2978 int UtcDaliVisualSetTransform1(void)
2980 ToolkitTestApplication application;
2981 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
2983 VisualFactory factory = VisualFactory::Get();
2984 Property::Map propertyMap;
2985 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
2986 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
2987 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
2988 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
2989 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
2990 Visual::Base visual = factory.CreateVisual(propertyMap);
2991 TestTransform(application, visual);
2992 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
2997 int UtcDaliVisualSetTransform2(void)
2999 ToolkitTestApplication application;
3000 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3002 VisualFactory factory = VisualFactory::Get();
3003 Property::Map propertyMap;
3004 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3005 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3007 Property::Array stopOffsets;
3008 stopOffsets.PushBack(0.0f);
3009 stopOffsets.PushBack(0.3f);
3010 stopOffsets.PushBack(0.6f);
3011 stopOffsets.PushBack(0.8f);
3012 stopOffsets.PushBack(1.0f);
3013 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3015 Property::Array stopColors;
3016 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3017 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3018 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3019 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3020 stopColors.PushBack(Color::YELLOW);
3021 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3022 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3023 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3024 Visual::Base visual = factory.CreateVisual(propertyMap);
3025 TestTransform(application, visual);
3026 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3031 int UtcDaliVisualSetTransform3(void)
3033 ToolkitTestApplication application;
3034 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3036 VisualFactory factory = VisualFactory::Get();
3037 Property::Map propertyMap;
3038 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3039 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3040 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3041 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3042 Visual::Base visual = factory.CreateVisual(propertyMap);
3043 TestTransform(application, visual);
3044 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3049 int UtcDaliVisualSetTransform4(void)
3051 ToolkitTestApplication application;
3052 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3054 VisualFactory factory = VisualFactory::Get();
3055 Property::Map propertyMap;
3056 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3057 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3059 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3060 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3061 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3062 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3063 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3064 Visual::Base visual = factory.CreateVisual(propertyMap);
3065 TestTransform(application, visual);
3066 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3071 int UtcDaliVisualSetTransform5(void)
3073 ToolkitTestApplication application;
3074 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3076 VisualFactory factory = VisualFactory::Get();
3077 Property::Map propertyMap;
3078 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3079 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3080 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3081 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3082 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3083 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3084 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3085 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3086 Visual::Base visual = factory.CreateVisual(propertyMap);
3087 TestTransform(application, visual);
3088 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3093 int UtcDaliVisualSetTransform6(void)
3095 ToolkitTestApplication application;
3096 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3098 VisualFactory factory = VisualFactory::Get();
3099 Property::Map propertyMap;
3100 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3101 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3102 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3103 Visual::Base visual = factory.CreateVisual(propertyMap);
3104 TestTransform(application, visual);
3105 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3110 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3112 ToolkitTestApplication application;
3113 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3115 VisualFactory factory = VisualFactory::Get();
3116 Property::Map propertyMap;
3117 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3118 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3119 Visual::Base visual = factory.CreateVisual(propertyMap);
3121 Property::Map transform;
3122 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3123 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3124 visual.SetTransformAndSize(transform, Vector2(100, 100));
3126 Dali::Property::Map visualMap;
3127 visual.CreatePropertyMap(visualMap);
3128 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3129 Dali::Property::Map* map = value->GetMap();
3130 DALI_TEST_CHECK(map);
3133 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3134 DALI_TEST_CHECK(typeValue);
3135 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3138 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3139 DALI_TEST_CHECK(typeValue);
3140 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3146 int UtcDaliNPatchVisualCustomShader(void)
3148 ToolkitTestApplication application;
3149 tet_infoline("NPatchVisual with custom shader");
3151 VisualFactory factory = VisualFactory::Get();
3152 Property::Map properties;
3153 Property::Map shader;
3154 const std::string vertexShader = "Foobar";
3155 const std::string fragmentShader = "Foobar";
3156 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3157 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3159 Property::Map transformMap;
3160 transformMap["size"] = Vector2(0.5f, 0.5f);
3161 transformMap["offset"] = Vector2(20.0f, 0.0f);
3162 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3163 transformMap["anchorPoint"] = Align::CENTER;
3164 transformMap["origin"] = Align::CENTER;
3165 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3166 properties[Visual::Property::TRANSFORM] = transformMap;
3168 properties[Visual::Property::TYPE] = Visual::IMAGE;
3169 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3170 properties[Visual::Property::SHADER] = shader;
3171 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3172 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3174 Visual::Base visual = factory.CreateVisual(properties);
3175 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3177 // trigger creation through setting on stage
3178 DummyControl dummy = DummyControl::New(true);
3179 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3180 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3181 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3182 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3183 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3184 application.GetScene().Add(dummy);
3185 application.SendNotification();
3187 Renderer renderer = dummy.GetRendererAt(0);
3188 Shader shader2 = renderer.GetShader();
3189 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3190 Property::Map* map = value.GetMap();
3191 DALI_TEST_CHECK(map);
3193 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3194 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3196 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3197 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3199 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3200 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3202 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3203 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3208 int UtcDaliGradientVisualBlendMode(void)
3210 ToolkitTestApplication application;
3211 VisualFactory factory = VisualFactory::Get();
3213 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3214 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)));
3216 Visual::Base alphaGradientVisual = factory.CreateVisual(
3217 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))));
3219 DummyControl control = DummyControl::New(true);
3220 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3221 application.GetScene().Add(control);
3223 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3224 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3225 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3227 application.SendNotification();
3228 application.Render();
3230 // 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
3231 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3232 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3233 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3238 int UtcDaliVisualRendererRemovalAndReAddition(void)
3240 ToolkitTestApplication application;
3241 tet_infoline("UtcDaliVisualRendererRemoval");
3243 VisualFactory factory = VisualFactory::Get();
3244 Property::Map propertyMap;
3245 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3246 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3247 Visual::Base visual = factory.CreateVisual(propertyMap);
3249 visual.SetDepthIndex(1);
3251 DummyControl dummyControl = DummyControl::New(true);
3252 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3253 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3254 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3256 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3257 tet_infoline("Add control with visual to stage and check renderer count is 1");
3259 application.GetScene().Add(dummyControl);
3261 application.SendNotification();
3262 application.Render();
3264 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3266 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3267 application.GetScene().Remove(dummyControl);
3268 application.SendNotification();
3269 application.Render();
3271 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3273 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3275 application.GetScene().Add(dummyControl);
3277 application.SendNotification();
3278 application.Render();
3280 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3285 int UtcDaliVisualTextVisualRender(void)
3287 ToolkitTestApplication application;
3288 tet_infoline("UtcDaliVisualTextVisualRender");
3290 VisualFactory factory = VisualFactory::Get();
3291 Property::Map propertyMap;
3292 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3293 propertyMap.Insert("mixColor", Color::WHITE);
3294 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3295 propertyMap.Insert("enableMarkup", false);
3296 propertyMap.Insert("text", "Hello world");
3297 propertyMap.Insert("fontFamily", "TizenSans");
3299 Property::Map fontStyleMapSet;
3300 fontStyleMapSet.Insert("weight", "bold");
3301 propertyMap.Insert("fontStyle", fontStyleMapSet);
3303 propertyMap.Insert("pointSize", 12.f);
3304 propertyMap.Insert("multiLine", true);
3305 propertyMap.Insert("horizontalAlignment", "CENTER");
3306 propertyMap.Insert("verticalAlignment", "CENTER");
3307 propertyMap.Insert("textColor", Color::RED);
3308 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3309 textVisual.SetDepthIndex(1);
3311 DummyControl dummyControl = DummyControl::New(true);
3312 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3313 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3314 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3316 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3317 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3319 application.GetScene().Add(dummyControl);
3320 application.SendNotification();
3321 application.Render();
3323 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3324 propertyMap.Clear();
3325 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3326 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3327 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3328 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3330 Property::Map transformMap;
3331 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3332 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3334 textVisual = factory.CreateVisual(propertyMap);
3335 textVisual.SetDepthIndex(1);
3337 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3338 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3340 application.SendNotification(); // force process events to ensure text visual
3341 // adds renderer to the dummy control in OnRelayout
3342 application.Render();
3344 Renderer renderer = dummyControl.GetRendererAt(0u);
3345 Property::Index index = renderer.GetPropertyIndex("transformSize");
3347 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3348 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3353 int UtcDaliVisualTextVisualDisableEnable(void)
3355 ToolkitTestApplication application;
3356 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3358 VisualFactory factory = VisualFactory::Get();
3359 Property::Map propertyMap;
3360 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3361 propertyMap.Insert("mixColor", Color::WHITE);
3362 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3363 propertyMap.Insert("enableMarkup", false);
3364 propertyMap.Insert("text", "Hello world");
3365 propertyMap.Insert("fontFamily", "TizenSans");
3367 Property::Map fontStyleMapSet;
3368 fontStyleMapSet.Insert("weight", "bold");
3369 propertyMap.Insert("fontStyle", fontStyleMapSet);
3371 propertyMap.Insert("pointSize", 12.f);
3372 propertyMap.Insert("multiLine", true);
3373 propertyMap.Insert("horizontalAlignment", "CENTER");
3374 propertyMap.Insert("verticalAlignment", "CENTER");
3375 propertyMap.Insert("textColor", Color::RED);
3376 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3377 textVisual.SetDepthIndex(1);
3379 DummyControl dummyControl = DummyControl::New(true);
3380 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3381 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3382 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3384 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3385 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3387 application.GetScene().Add(dummyControl);
3388 application.SendNotification();
3389 application.Render();
3391 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3393 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3395 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3397 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3399 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3404 int UtcDaliVisualPremultipliedAlpha(void)
3406 ToolkitTestApplication application;
3407 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3409 VisualFactory factory = VisualFactory::Get();
3411 // image visual, test default value ( true )
3413 Visual::Base imageVisual = factory.CreateVisual(
3415 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3416 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3418 Dali::Property::Map visualMap;
3419 imageVisual.CreatePropertyMap(visualMap);
3420 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3423 DALI_TEST_CHECK(value);
3424 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3427 // image visual, override premultiplied
3429 Visual::Base imageVisual = factory.CreateVisual(
3431 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3432 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3433 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3435 Dali::Property::Map visualMap;
3436 imageVisual.CreatePropertyMap(visualMap);
3437 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3440 DALI_TEST_CHECK(value);
3441 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3444 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3446 Visual::Base imageVisual = factory.CreateVisual(
3448 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3449 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3451 Dali::Property::Map visualMap;
3452 imageVisual.CreatePropertyMap(visualMap);
3453 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3456 DALI_TEST_CHECK(value);
3457 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3460 Visual::Base imageVisual = factory.CreateVisual(
3462 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3463 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3464 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
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 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3477 Visual::Base imageVisual = factory.CreateVisual(
3479 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3480 .Add(ImageVisual::Property::URL, "something.json"));
3482 Dali::Property::Map visualMap;
3483 imageVisual.CreatePropertyMap(visualMap);
3484 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3487 DALI_TEST_CHECK(value);
3488 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3491 Visual::Base imageVisual = factory.CreateVisual(
3493 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3494 .Add(ImageVisual::Property::URL, "something.json")
3495 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
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 // text visual ( premultiplied alpha by default is true, and cannot change value )
3508 Visual::Base textVisual = factory.CreateVisual(
3510 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3511 .Add(TextVisual::Property::TEXT, "Text"));
3513 Dali::Property::Map visualMap;
3514 textVisual.CreatePropertyMap(visualMap);
3515 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3518 DALI_TEST_CHECK(value);
3519 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3522 Visual::Base textVisual = factory.CreateVisual(
3524 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3525 .Add(TextVisual::Property::TEXT, "Text")
3526 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
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 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3539 Visual::Base gradientVisual = factory.CreateVisual(
3541 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3542 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3543 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3544 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3546 Dali::Property::Map visualMap;
3547 gradientVisual.CreatePropertyMap(visualMap);
3548 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3551 DALI_TEST_CHECK(value);
3552 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3555 Visual::Base gradientVisual = factory.CreateVisual(
3557 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3558 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3559 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3560 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3561 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3563 Dali::Property::Map visualMap;
3564 gradientVisual.CreatePropertyMap(visualMap);
3565 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3568 DALI_TEST_CHECK(value);
3569 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3572 // color visual ( premultiplied alpha by default is false, and cannot change value )
3574 Visual::Base colorVisual = factory.CreateVisual(
3576 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3577 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3579 Dali::Property::Map visualMap;
3580 colorVisual.CreatePropertyMap(visualMap);
3581 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3584 DALI_TEST_CHECK(value);
3585 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3588 Visual::Base colorVisual = factory.CreateVisual(
3590 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3591 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3592 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
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);
3606 int UtcDaliRegisterVisualOrder(void)
3608 ToolkitTestApplication application;
3609 tet_infoline("Register Visual Order");
3611 DummyControl dummyControl = DummyControl::New(true);
3612 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3614 VisualFactory factory = VisualFactory::Get();
3615 Property::Map propertyMap;
3616 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3617 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3619 tet_infoline("Register visual, should have depth index of 0.0f");
3620 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3621 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3622 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3624 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3626 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3627 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3628 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3630 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3631 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3632 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3634 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3635 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3636 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3638 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3639 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3640 labelVisual.SetDepthIndex(-2000);
3641 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3642 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3644 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3645 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3646 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3647 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3648 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3649 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3651 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3652 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3653 anotherTestVisual2Replacement.SetDepthIndex(2000);
3654 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3655 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3657 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3658 application.GetScene().Add(dummyControl);
3663 int UtcDaliRegisterVisualOrder02(void)
3665 ToolkitTestApplication application;
3666 tet_infoline("Register Visual Order with Background Set");
3668 DummyControl dummyControl = DummyControl::New(true);
3669 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3671 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3673 VisualFactory factory = VisualFactory::Get();
3674 Property::Map propertyMap;
3675 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3676 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3678 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3680 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3682 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3683 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3684 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3685 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3686 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3688 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3689 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3690 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3691 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3693 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3694 application.GetScene().Add(dummyControl);
3699 int UtcDaliRegisterVisualWithDepthIndex(void)
3701 ToolkitTestApplication application;
3702 tet_infoline("Register a Visual With Depth Index");
3704 DummyControl dummyControl = DummyControl::New(true);
3705 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3707 VisualFactory factory = VisualFactory::Get();
3708 Property::Map propertyMap;
3709 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3710 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3712 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3713 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3714 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3715 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3716 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3718 tet_infoline("Register another visual with a depth index and it disabled");
3719 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3720 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3721 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3722 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3724 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3725 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3726 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3727 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3728 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3730 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3731 application.GetScene().Add(dummyControl);
3736 int UtcDaliSvgVisualCustomShader(void)
3738 ToolkitTestApplication application;
3739 tet_infoline("SvgVisual with custom shader");
3741 VisualFactory factory = VisualFactory::Get();
3742 Property::Map properties;
3743 Property::Map shader;
3744 const std::string vertexShader = "Foobar";
3745 const std::string fragmentShader = "Foobar";
3746 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3747 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3749 properties[Visual::Property::TYPE] = Visual::IMAGE;
3750 properties[Visual::Property::SHADER] = shader;
3751 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3753 Visual::Base visual = factory.CreateVisual(properties);
3755 // trigger creation through setting on stage
3756 DummyControl dummy = DummyControl::New(true);
3757 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3758 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3760 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3761 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3762 application.GetScene().Add(dummy);
3764 application.SendNotification();
3765 application.Render();
3767 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3769 Renderer renderer = dummy.GetRendererAt(0);
3770 Shader shader2 = renderer.GetShader();
3771 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3772 Property::Map* map = value.GetMap();
3773 DALI_TEST_CHECK(map);
3775 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3776 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3778 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3779 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3784 int UtcDaliVisualRoundedCorner(void)
3786 ToolkitTestApplication application;
3787 tet_infoline("UtcDaliVisualRoundedCorner");
3789 static std::vector<UniformData> customUniforms =
3791 UniformData("cornerRadius", Property::Type::VECTOR4),
3792 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3795 TestGraphicsController& graphics = application.GetGraphicsController();
3796 graphics.AddCustomUniforms(customUniforms);
3800 VisualFactory factory = VisualFactory::Get();
3801 Property::Map properties;
3802 float cornerRadius = 30.0f;
3804 properties[Visual::Property::TYPE] = Visual::IMAGE;
3805 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3806 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3808 Visual::Base visual = factory.CreateVisual(properties);
3810 // trigger creation through setting on stage
3811 DummyControl dummy = DummyControl::New(true);
3812 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3813 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3815 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3816 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3817 application.GetScene().Add(dummy);
3819 application.SendNotification();
3820 application.Render();
3822 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3824 application.SendNotification();
3825 application.Render();
3827 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3828 // Default corner radius policy is absolute.
3829 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3834 VisualFactory factory = VisualFactory::Get();
3835 Property::Map properties;
3836 float cornerRadius = 30.0f;
3838 properties[Visual::Property::TYPE] = Visual::COLOR;
3839 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3840 properties["cornerRadius"] = cornerRadius;
3841 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3843 Visual::Base visual = factory.CreateVisual(properties);
3845 // trigger creation through setting on stage
3846 DummyControl dummy = DummyControl::New(true);
3847 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3848 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3850 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3851 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3852 application.GetScene().Add(dummy);
3854 application.SendNotification();
3855 application.Render();
3857 application.SendNotification();
3858 application.Render();
3860 // Currently test with multiple program doesn't work well. will fix another day
3861 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3862 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3867 VisualFactory factory = VisualFactory::Get();
3868 Property::Map properties;
3869 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3871 properties[Visual::Property::TYPE] = Visual::COLOR;
3872 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3873 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3874 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3876 Visual::Base visual = factory.CreateVisual(properties);
3878 // trigger creation through setting on stage
3879 DummyControl dummy = DummyControl::New(true);
3880 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3881 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3883 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3884 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3885 application.GetScene().Add(dummy);
3887 application.SendNotification();
3888 application.Render();
3890 application.SendNotification();
3891 application.Render();
3893 // Currently test with multiple program doesn't work well. will fix another day
3894 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3895 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3898 // color visual 3 - invalid value
3900 VisualFactory factory = VisualFactory::Get();
3901 Property::Map properties;
3902 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3904 properties[Visual::Property::TYPE] = Visual::COLOR;
3905 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3906 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3907 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3909 Visual::Base visual = factory.CreateVisual(properties);
3911 // trigger creation through setting on stage
3912 DummyControl dummy = DummyControl::New(true);
3913 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3914 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3916 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3917 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3918 application.GetScene().Add(dummy);
3920 application.SendNotification();
3921 application.Render();
3923 application.SendNotification();
3924 application.Render();
3926 // Currently test with multiple program doesn't work well. will fix another day
3927 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3928 // Default corner radius policy is absolute.
3929 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3934 VisualFactory factory = VisualFactory::Get();
3935 Property::Map properties;
3936 float cornerRadius = 30.0f;
3938 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3939 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3940 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3941 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3942 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3943 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3945 Property::Array stopOffsets;
3946 stopOffsets.PushBack(0.0f);
3947 stopOffsets.PushBack(0.6f);
3948 stopOffsets.PushBack(1.0f);
3949 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3951 Property::Array stopColors;
3952 stopColors.PushBack(Color::RED);
3953 stopColors.PushBack(Color::YELLOW);
3954 stopColors.PushBack(Color::GREEN);
3955 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3957 Visual::Base visual = factory.CreateVisual(properties);
3959 // trigger creation through setting on stage
3960 DummyControl dummy = DummyControl::New(true);
3961 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3962 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3964 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3965 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3966 application.GetScene().Add(dummy);
3968 application.SendNotification();
3969 application.Render();
3971 application.SendNotification();
3972 application.Render();
3974 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3975 // Default corner radius policy is absolute.
3976 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3979 // animated image visual
3981 VisualFactory factory = VisualFactory::Get();
3982 Property::Map properties;
3983 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3985 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3986 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3987 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
3988 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3989 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3991 Visual::Base visual = factory.CreateVisual(properties);
3993 // trigger creation through setting on stage
3994 DummyControl dummy = DummyControl::New(true);
3995 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3996 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3998 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3999 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4000 application.GetScene().Add(dummy);
4002 application.SendNotification();
4003 application.Render();
4005 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4007 application.SendNotification();
4008 application.Render();
4010 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4011 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4014 // vector image visual
4016 VisualFactory factory = VisualFactory::Get();
4017 Property::Map properties;
4018 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4020 properties[Visual::Property::TYPE] = Visual::SVG;
4021 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4022 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4024 Visual::Base visual = factory.CreateVisual(properties);
4026 // trigger creation through setting on stage
4027 DummyControl dummy = DummyControl::New(true);
4028 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4029 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4031 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4032 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4033 application.GetScene().Add(dummy);
4035 application.SendNotification();
4036 application.Render();
4038 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4040 application.SendNotification();
4041 application.Render();
4043 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4044 // Default corner radius policy is absolute.
4045 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4048 // animated vector image visual
4050 VisualFactory factory = VisualFactory::Get();
4051 Property::Map properties;
4052 float cornerRadius = 1.3f;
4054 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4055 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4056 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4057 properties["cornerRadius"] = cornerRadius;
4058 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4060 Visual::Base visual = factory.CreateVisual(properties);
4062 // trigger creation through setting on stage
4063 DummyControl dummy = DummyControl::New(true);
4064 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4065 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4067 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4068 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4069 application.GetScene().Add(dummy);
4071 application.SendNotification();
4072 application.Render();
4074 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4076 application.SendNotification();
4077 application.Render();
4079 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4080 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4086 int UtcDaliVisualBorderline(void)
4088 ToolkitTestApplication application;
4089 tet_infoline("UtcDaliVisualBorderline");
4091 static std::vector<UniformData> customUniforms =
4093 UniformData("cornerRadius", Property::Type::VECTOR4),
4094 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4095 UniformData("borderlineWidth", Property::Type::FLOAT),
4096 UniformData("borderlineColor", Property::Type::VECTOR4),
4097 UniformData("borderlineOffset", Property::Type::FLOAT),
4100 TestGraphicsController& graphics = application.GetGraphicsController();
4101 graphics.AddCustomUniforms(customUniforms);
4105 VisualFactory factory = VisualFactory::Get();
4106 Property::Map properties;
4107 float cornerRadius = 5.0f;
4108 float borderlineWidth = 30.0f;
4109 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4110 float borderlineOffset = 1.0f;
4112 properties[Visual::Property::TYPE] = Visual::IMAGE;
4113 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4114 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4115 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4116 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4117 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4119 Visual::Base visual = factory.CreateVisual(properties);
4121 // trigger creation through setting on stage
4122 DummyControl dummy = DummyControl::New(true);
4123 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4124 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4126 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4127 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4128 application.GetScene().Add(dummy);
4130 application.SendNotification();
4131 application.Render();
4133 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4135 application.SendNotification();
4136 application.Render();
4138 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4139 // Default corner radius policy is absolute.
4140 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4141 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4142 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4143 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4148 VisualFactory factory = VisualFactory::Get();
4149 Property::Map properties;
4150 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4151 float borderlineWidth = 30.0f;
4152 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4153 float borderlineOffset = -0.4f;
4155 properties[Visual::Property::TYPE] = Visual::COLOR;
4156 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4157 properties["cornerRadius"] = cornerRadius;
4158 properties["borderlineWidth"] = borderlineWidth;
4159 properties["borderlineColor"] = borderlineColor;
4160 properties["borderlineOffset"] = borderlineOffset;
4162 Visual::Base visual = factory.CreateVisual(properties);
4164 // trigger creation through setting on stage
4165 DummyControl dummy = DummyControl::New(true);
4166 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4167 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4169 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4170 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4171 application.GetScene().Add(dummy);
4173 application.SendNotification();
4174 application.Render();
4176 application.SendNotification();
4177 application.Render();
4179 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4180 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4181 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4182 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4185 // color visual 2, default color, default offset
4187 VisualFactory factory = VisualFactory::Get();
4188 Property::Map properties;
4189 float borderlineWidth = 30.0f;
4191 properties[Visual::Property::TYPE] = Visual::COLOR;
4192 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4193 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4195 Visual::Base visual = factory.CreateVisual(properties);
4197 // trigger creation through setting on stage
4198 DummyControl dummy = DummyControl::New(true);
4199 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4200 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4202 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4203 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4204 application.GetScene().Add(dummy);
4206 application.SendNotification();
4207 application.Render();
4209 application.SendNotification();
4210 application.Render();
4212 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4213 // Default borderline color is BLACK.
4214 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4215 // Default borderline offset is 0.0f.
4216 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4219 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4221 VisualFactory factory = VisualFactory::Get();
4222 Property::Map properties;
4223 float borderlineWidth = 30.0f;
4224 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4225 float borderlineOffset = 37.4f;
4227 properties[Visual::Property::TYPE] = Visual::COLOR;
4228 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4229 properties["borderlineWidth"] = borderlineWidth;
4230 properties["borderlineColor"] = borderlineColor;
4231 properties["borderlineOffset"] = borderlineOffset;
4233 Visual::Base visual = factory.CreateVisual(properties);
4235 // trigger creation through setting on stage
4236 DummyControl dummy = DummyControl::New(true);
4237 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4238 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4240 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4241 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4242 application.GetScene().Add(dummy);
4244 application.SendNotification();
4245 application.Render();
4247 application.SendNotification();
4248 application.Render();
4250 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4251 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4252 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4253 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4258 VisualFactory factory = VisualFactory::Get();
4259 Property::Map properties;
4260 float borderlineWidth = 30.0f;
4261 float cornerRadius = 70.0f;
4263 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4264 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4265 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4266 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4267 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4268 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4269 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4271 Property::Array stopOffsets;
4272 stopOffsets.PushBack(0.0f);
4273 stopOffsets.PushBack(0.6f);
4274 stopOffsets.PushBack(1.0f);
4275 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4277 Property::Array stopColors;
4278 stopColors.PushBack(Color::RED);
4279 stopColors.PushBack(Color::YELLOW);
4280 stopColors.PushBack(Color::GREEN);
4281 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4283 Visual::Base visual = factory.CreateVisual(properties);
4285 // trigger creation through setting on stage
4286 DummyControl dummy = DummyControl::New(true);
4287 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4288 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4290 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4291 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4292 application.GetScene().Add(dummy);
4294 application.SendNotification();
4295 application.Render();
4297 application.SendNotification();
4298 application.Render();
4300 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4301 // Default corner radius policy is absolute.
4302 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4303 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4304 // Default borderline color is BLACK.
4305 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4306 // Default borderline offset is 0.0f.
4307 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4310 // animated image visual
4312 VisualFactory factory = VisualFactory::Get();
4313 Property::Map properties;
4314 float borderlineWidth = 24.0f;
4315 float borderlineOffset = -1.0f;
4317 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4318 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4319 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4320 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4321 properties["borderlineOffset"] = borderlineOffset;
4323 Visual::Base visual = factory.CreateVisual(properties);
4325 // trigger creation through setting on stage
4326 DummyControl dummy = DummyControl::New(true);
4327 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4328 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4330 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4331 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4332 application.GetScene().Add(dummy);
4334 application.SendNotification();
4335 application.Render();
4337 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4339 application.SendNotification();
4340 application.Render();
4342 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4343 // Default borderline color is BLACK.
4344 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4345 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4348 // vector image visual
4350 VisualFactory factory = VisualFactory::Get();
4351 Property::Map properties;
4352 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4353 float borderlineWidth = 27.0f;
4354 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4356 properties[Visual::Property::TYPE] = Visual::SVG;
4357 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4358 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4359 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4360 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4362 Visual::Base visual = factory.CreateVisual(properties);
4364 // trigger creation through setting on stage
4365 DummyControl dummy = DummyControl::New(true);
4366 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4367 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4369 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4370 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4371 application.GetScene().Add(dummy);
4373 application.SendNotification();
4374 application.Render();
4376 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4378 application.SendNotification();
4379 application.Render();
4381 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4382 // Default corner radius policy is absolute.
4383 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4384 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4385 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4386 // Default borderline offset is 0.0.
4387 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4390 // animated vector image visual
4392 VisualFactory factory = VisualFactory::Get();
4393 Property::Map properties;
4394 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4395 float borderlineWidth = 13.0f;
4396 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4397 float borderlineOffset = 13.0f;
4399 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4400 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4401 properties["cornerRadius"] = cornerRadius;
4402 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4403 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4404 properties["borderlineColor"] = borderlineColor;
4405 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4407 Visual::Base visual = factory.CreateVisual(properties);
4409 // trigger creation through setting on stage
4410 DummyControl dummy = DummyControl::New(true);
4411 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4412 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4414 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4415 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4416 application.GetScene().Add(dummy);
4418 application.SendNotification();
4419 application.Render();
4421 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4423 application.SendNotification();
4424 application.Render();
4426 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4427 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4428 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4429 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4430 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4436 int UtcDaliVisualBorderlineBlendModeTest(void)
4438 ToolkitTestApplication application;
4439 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4440 VisualFactory factory = VisualFactory::Get();
4442 // Case 1 : Test which doesn't support borderline feature.
4444 tet_printf("Test Unsupported visual type\n");
4445 Property::Map propertyMap;
4446 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4447 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4448 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4449 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4451 DummyControl actor = DummyControl::New(true);
4452 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4453 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4454 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4455 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4456 application.GetScene().Add(actor);
4458 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4460 Renderer renderer = actor.GetRendererAt(0);
4462 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4463 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4464 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4466 application.GetScene().Remove(actor);
4469 // Case 2 : Test which support borderline feature.
4471 tet_printf("Test normal case\n");
4472 Property::Map propertyMap;
4473 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4474 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4475 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4476 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4478 DummyControl actor = DummyControl::New(true);
4479 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4480 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4481 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4482 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4483 application.GetScene().Add(actor);
4485 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4487 Renderer renderer = actor.GetRendererAt(0);
4489 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4490 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4491 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4493 application.GetScene().Remove(actor);
4496 // Case 3 : Test which animated borderline.
4498 tet_printf("Test borderline animate case\n");
4499 Property::Map propertyMap;
4500 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4501 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4502 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4504 DummyControl actor = DummyControl::New(true);
4505 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4506 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4507 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4508 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4509 application.GetScene().Add(actor);
4511 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4513 Renderer renderer = actor.GetRendererAt(0);
4515 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4516 // BlendMode is AUTO.
4517 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4519 Animation animation = Animation::New(0.1f);
4520 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4523 application.SendNotification();
4524 application.Render();
4525 application.Render(101u); // End of animation
4527 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4528 // BlendMode is ON_WITHOUT_CULL.
4529 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4531 Animation revanimation = Animation::New(0.1f);
4532 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4533 revanimation.Play();
4535 application.SendNotification();
4536 application.Render();
4537 application.Render(101u); // End of animation
4539 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4540 // BlendMode is still ON_WITHOUT_CULL.
4541 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4543 application.GetScene().Remove(actor);
4546 // Case 4 : Test which animated corner radius occur.
4548 tet_printf("Test borderline animate case\n");
4549 Property::Map propertyMap;
4550 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4551 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4552 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4553 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4555 DummyControl actor = DummyControl::New(true);
4556 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4557 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4558 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4559 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4560 application.GetScene().Add(actor);
4562 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4564 Renderer renderer = actor.GetRendererAt(0);
4566 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4567 // BlendMode is ON_WITHOUT_CULL.
4568 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4570 Animation animation = Animation::New(0.1f);
4571 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4574 application.SendNotification();
4575 application.Render();
4576 application.Render(101u); // End of animation
4578 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4579 // BlendMode is ON_WITHOUT_CULL.
4580 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4582 application.GetScene().Remove(actor);
4588 int UtcDaliVisualBorderlineColorAnimateTest(void)
4590 ToolkitTestApplication application;
4591 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4593 TestGraphicsController& graphics = application.GetGraphicsController();
4594 static std::vector<UniformData> customUniforms =
4596 UniformData("mixColor", Property::Type::VECTOR3),
4597 UniformData("cornerRadius", Property::Type::VECTOR4),
4598 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4599 UniformData("borderlineWidth", Property::Type::FLOAT),
4600 UniformData("borderlineColor", Property::Type::VECTOR4),
4601 UniformData("borderlineOffset", Property::Type::FLOAT),
4603 graphics.AddCustomUniforms(customUniforms);
4606 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4607 const float INITIAL_MIX_OPACITY(0.5f);
4608 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4609 const float INITIAL_ACTOR_OPACITY(1.0f);
4610 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4611 const float TARGET_MIX_OPACITY(0.8f);
4612 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4613 const float TARGET_ACTOR_OPACITY(0.5f);
4615 VisualFactory factory = VisualFactory::Get();
4616 Property::Map propertyMap;
4617 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4618 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4619 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4620 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4621 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4622 Visual::Base visual = factory.CreateVisual(propertyMap);
4624 DummyControl actor = DummyControl::New(true);
4625 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4626 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4627 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4628 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4629 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4630 application.GetScene().Add(actor);
4632 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4634 Animation animation = Animation::New(4.0f);
4635 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4636 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4637 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4638 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4641 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4643 application.SendNotification();
4644 application.Render(0);
4645 application.Render(2000u); // halfway point
4646 application.SendNotification();
4648 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4649 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4650 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4651 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4652 halfwayMixOpacity *= halfwayActorOpacity;
4653 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4654 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4655 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4656 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4658 application.Render(2001u); // go past end
4659 application.SendNotification(); // Trigger signals
4661 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4662 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4663 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4664 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4665 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4673 int UtcDaliColorVisualBlurRadius(void)
4675 ToolkitTestApplication application;
4676 tet_infoline("UtcDaliColorVisualBlurRadius");
4678 static std::vector<UniformData> customUniforms =
4680 UniformData("blurRadius", Property::Type::FLOAT),
4683 TestGraphicsController& graphics = application.GetGraphicsController();
4684 graphics.AddCustomUniforms(customUniforms);
4686 VisualFactory factory = VisualFactory::Get();
4687 Property::Map properties;
4688 float blurRadius = 20.0f;
4690 properties[Visual::Property::TYPE] = Visual::COLOR;
4691 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4692 properties["blurRadius"] = blurRadius;
4694 Visual::Base visual = factory.CreateVisual(properties);
4696 // trigger creation through setting on stage
4697 DummyControl dummy = DummyControl::New(true);
4698 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4699 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4701 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4702 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4703 application.GetScene().Add(dummy);
4705 application.SendNotification();
4706 application.Render();
4708 application.SendNotification();
4709 application.Render();
4711 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4716 int UtcDaliVisualGetType(void)
4718 ToolkitTestApplication application;
4719 tet_infoline("UtcDaliVisualGetType");
4721 VisualFactory factory = VisualFactory::Get();
4724 Property::Map properties;
4725 properties[Visual::Property::TYPE] = Visual::BORDER;
4726 Visual::Base visual = factory.CreateVisual(properties);
4728 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4732 Property::Map properties;
4733 properties[Visual::Property::TYPE] = Visual::COLOR;
4734 Visual::Base visual = factory.CreateVisual(properties);
4736 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4740 Property::Map properties;
4741 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4742 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4743 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4744 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4745 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4746 Property::Array stopColors;
4747 stopColors.PushBack(Color::RED);
4748 stopColors.PushBack(Color::GREEN);
4749 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4750 Visual::Base visual = factory.CreateVisual(properties);
4752 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4756 Property::Map properties;
4757 properties[Visual::Property::TYPE] = Visual::IMAGE;
4758 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4759 Visual::Base visual = factory.CreateVisual(properties);
4761 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4765 Property::Map properties;
4766 properties[Visual::Property::TYPE] = Visual::MESH;
4767 Visual::Base visual = factory.CreateVisual(properties);
4769 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4773 Property::Map properties;
4774 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4775 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4776 Visual::Base visual = factory.CreateVisual(properties);
4778 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4782 Property::Map properties;
4783 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4784 Visual::Base visual = factory.CreateVisual(properties);
4786 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4790 Property::Map properties;
4791 properties[Visual::Property::TYPE] = Visual::TEXT;
4792 Visual::Base visual = factory.CreateVisual(properties);
4794 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4798 Property::Map properties;
4799 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4800 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4801 Visual::Base visual = factory.CreateVisual(properties);
4803 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4807 Property::Map properties;
4808 properties[Visual::Property::TYPE] = Visual::SVG;
4809 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4810 Visual::Base visual = factory.CreateVisual(properties);
4812 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4816 Property::Map properties;
4817 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4818 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4819 Visual::Base visual = factory.CreateVisual(properties);
4821 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4825 Property::Map properties;
4826 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4827 Visual::Base visual = factory.CreateVisual(properties);
4829 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4833 Property::Map properties;
4834 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4835 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4836 Visual::Base visual = factory.CreateVisual(properties);
4838 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4842 Property::Map properties;
4843 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4844 Visual::Base visual = factory.CreateVisual(properties);
4846 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4852 int UtcDaliVisualGetVisualProperty01(void)
4854 ToolkitTestApplication application;
4855 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4857 static std::vector<UniformData> customUniforms =
4859 UniformData("mixColor", Property::Type::VECTOR3),
4860 UniformData("offset", Property::Type::VECTOR2),
4861 UniformData("size", Property::Type::VECTOR2),
4862 UniformData("cornerRadius", Property::Type::VECTOR4),
4863 UniformData("blurRadius", Property::Type::FLOAT),
4864 UniformData("borderlineWidth", Property::Type::FLOAT),
4865 UniformData("borderlineColor", Property::Type::VECTOR4),
4866 UniformData("borderlineOffset", Property::Type::FLOAT)};
4868 TestGraphicsController& graphics = application.GetGraphicsController();
4869 graphics.AddCustomUniforms(customUniforms);
4871 VisualFactory factory = VisualFactory::Get();
4872 Property::Map propertyMap;
4873 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4874 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4875 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4876 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4877 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4878 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4879 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4880 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4881 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4883 DummyControl dummyControl = DummyControl::New(true);
4884 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4885 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4886 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4887 application.GetScene().Add(dummyControl);
4889 application.SendNotification();
4890 application.Render();
4892 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4893 Vector2 targetOffset(0.05f, 0.05f);
4894 Vector2 targetSize(1.1f, 1.1f);
4895 float targetOpacity = 0.5f;
4896 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4897 float targetBlurRadius = 10.0f;
4898 float targetBorderlineWidth = 25.0f;
4899 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4900 float targetBorderlineOffset = -1.0f;
4902 Animation animation = Animation::New(1.0f);
4903 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4904 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4905 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4906 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4907 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4908 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4909 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4910 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4911 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4914 application.SendNotification();
4915 application.Render();
4916 application.Render(1001u); // End of animation
4918 Property::Map resultMap;
4919 colorVisual.CreatePropertyMap(resultMap);
4921 // Test property values: they should be updated
4922 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4923 DALI_TEST_CHECK(colorValue);
4924 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4926 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4927 Dali::Property::Map* transformMap = transformValue->GetMap();
4928 DALI_TEST_CHECK(transformMap);
4930 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4931 DALI_TEST_CHECK(offsetValue);
4932 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4934 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4935 DALI_TEST_CHECK(sizeValue);
4936 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4938 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4939 DALI_TEST_CHECK(cornerRadiusValue);
4940 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4942 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4943 DALI_TEST_CHECK(blurRadiusValue);
4944 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4946 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4947 DALI_TEST_CHECK(borderlineWidthValue);
4948 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4950 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4951 DALI_TEST_CHECK(borderlineColorValue);
4952 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4954 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4955 DALI_TEST_CHECK(borderlineOffsetValue);
4956 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4958 // Test uniform values
4959 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4960 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4961 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4962 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4963 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4964 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4965 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4966 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4968 // Test unregistered visual
4969 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4970 DALI_TEST_CHECK(!property3.object);
4971 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4976 int UtcDaliVisualGetVisualProperty02(void)
4978 ToolkitTestApplication application;
4979 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
4981 static std::vector<UniformData> customUniforms =
4983 UniformData("mixColor", Property::Type::VECTOR3),
4984 UniformData("offset", Property::Type::VECTOR2),
4985 UniformData("size", Property::Type::VECTOR2),
4986 UniformData("cornerRadius", Property::Type::VECTOR4),
4987 UniformData("borderlineWidth", Property::Type::FLOAT),
4988 UniformData("borderlineCOlor", Property::Type::VECTOR4),
4989 UniformData("borderlineOffset", Property::Type::FLOAT),
4990 UniformData("blurRadius", Property::Type::FLOAT),
4993 TestGraphicsController& graphics = application.GetGraphicsController();
4994 graphics.AddCustomUniforms(customUniforms);
4996 VisualFactory factory = VisualFactory::Get();
4997 Property::Map propertyMap;
4998 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4999 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5001 DummyControl dummyControl = DummyControl::New(true);
5002 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5003 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5004 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5005 application.GetScene().Add(dummyControl);
5007 application.SendNotification();
5008 application.Render();
5010 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5011 Vector2 targetOffset(0.05f, 0.05f);
5012 Vector2 targetSize(1.1f, 1.1f);
5013 float targetOpacity = 0.5f;
5014 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5015 float targetBorderlineWidth = 77.7f;
5016 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5017 float targetBorderlineOffset = 1.0f;
5018 float targetBlurRadius = 10.0f;
5020 // Should work when the properties are not set before
5021 Animation animation = Animation::New(1.0f);
5022 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5023 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5024 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5025 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5026 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5027 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5028 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5029 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5030 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5033 application.SendNotification();
5034 application.Render();
5035 application.Render(1001u); // End of animation
5037 Property::Map resultMap;
5038 colorVisual.CreatePropertyMap(resultMap);
5040 // Test property values: they should be updated
5041 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5042 DALI_TEST_CHECK(colorValue);
5043 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5045 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5046 Dali::Property::Map* transformMap = transformValue->GetMap();
5047 DALI_TEST_CHECK(transformMap);
5049 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5050 DALI_TEST_CHECK(offsetValue);
5051 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5053 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5054 DALI_TEST_CHECK(sizeValue);
5055 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5057 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5058 DALI_TEST_CHECK(cornerRadiusValue);
5059 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5061 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5062 DALI_TEST_CHECK(borderlineWidthValue);
5063 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5065 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5066 DALI_TEST_CHECK(borderlineColorValue);
5067 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5069 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5070 DALI_TEST_CHECK(borderlineOffsetValue);
5071 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5073 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5074 DALI_TEST_CHECK(blurRadiusValue);
5075 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5077 // Test uniform values
5078 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5079 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5080 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5081 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5082 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5087 int UtcDaliVisualGetVisualProperty03(void)
5089 ToolkitTestApplication application;
5090 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5092 static std::vector<UniformData> customUniforms =
5094 UniformData("cornerRadius", Property::Type::VECTOR4),
5095 UniformData("borderlineWidth", Property::Type::FLOAT),
5096 UniformData("borderlineColor", Property::Type::VECTOR4),
5097 UniformData("borderlineOffset", Property::Type::FLOAT),
5100 TestGraphicsController& graphics = application.GetGraphicsController();
5101 graphics.AddCustomUniforms(customUniforms);
5103 VisualFactory factory = VisualFactory::Get();
5104 Property::Map propertyMap;
5105 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5106 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5108 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5110 DummyControl dummyControl = DummyControl::New(true);
5111 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5112 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5113 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5114 application.GetScene().Add(dummyControl);
5116 // Wait for image loading
5117 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5119 application.SendNotification();
5120 application.Render();
5122 float targetOpacity = 0.5f;
5123 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5124 float targetBorderlineWidth = 10.0f;
5125 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5126 float targetBorderlineOffset = -1.5f;
5128 Animation animation = Animation::New(1.0f);
5129 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5130 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5131 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5132 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5133 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5136 application.SendNotification();
5137 application.Render();
5138 application.Render(1001u); // End of animation
5140 Property::Map resultMap;
5141 imageVisual.CreatePropertyMap(resultMap);
5143 // Test property values: they should be updated
5144 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5145 DALI_TEST_CHECK(colorValue);
5146 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5148 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5149 DALI_TEST_CHECK(cornerRadiusValue);
5150 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5152 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5153 DALI_TEST_CHECK(borderlineWidthValue);
5154 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5156 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5157 DALI_TEST_CHECK(borderlineColorValue);
5158 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5160 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5161 DALI_TEST_CHECK(borderlineOffsetValue);
5162 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5164 // Test uniform value
5165 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5166 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5167 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5168 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5173 int UtcDaliVisualGetVisualProperty04(void)
5175 ToolkitTestApplication application;
5176 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5178 static std::vector<UniformData> customUniforms =
5180 UniformData("cornerRadius", Property::Type::VECTOR4),
5183 TestGraphicsController& graphics = application.GetGraphicsController();
5184 graphics.AddCustomUniforms(customUniforms);
5186 Vector2 start(-1.f, -1.f);
5187 Vector2 end(1.f, 1.f);
5188 Property::Array stopColors;
5189 stopColors.PushBack(Color::RED);
5190 stopColors.PushBack(Color::GREEN);
5192 VisualFactory factory = VisualFactory::Get();
5193 Property::Map propertyMap;
5194 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5195 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5196 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5197 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5198 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5199 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5200 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5202 DummyControl dummyControl = DummyControl::New(true);
5203 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5204 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5205 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5206 application.GetScene().Add(dummyControl);
5208 application.SendNotification();
5209 application.Render();
5211 float targetOpacity = 0.5f;
5212 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5214 Animation animation = Animation::New(1.0f);
5215 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5216 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5219 application.SendNotification();
5220 application.Render();
5221 application.Render(1001u); // End of animation
5223 Property::Map resultMap;
5224 gradientVisual.CreatePropertyMap(resultMap);
5226 // Test property values: they should be updated
5227 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5228 DALI_TEST_CHECK(colorValue);
5229 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5231 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5232 DALI_TEST_CHECK(cornerRadiusValue);
5233 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5235 // Test uniform value
5236 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5241 int UtcDaliVisualGetVisualProperty05(void)
5243 ToolkitTestApplication application;
5244 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5246 static std::vector<UniformData> customUniforms =
5248 UniformData("cornerRadius", Property::Type::VECTOR4),
5249 UniformData("borderlineWidth", Property::Type::FLOAT),
5250 UniformData("borderlineColor", Property::Type::VECTOR4),
5251 UniformData("borderlineOffset", Property::Type::FLOAT),
5254 TestGraphicsController& graphics = application.GetGraphicsController();
5255 graphics.AddCustomUniforms(customUniforms);
5257 VisualFactory factory = VisualFactory::Get();
5258 Property::Map propertyMap;
5259 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5260 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5262 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5264 DummyControl dummyControl = DummyControl::New(true);
5265 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5266 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5267 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5268 application.GetScene().Add(dummyControl);
5270 application.SendNotification();
5271 application.Render();
5273 // Wait for image loading
5274 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5276 application.SendNotification();
5277 application.Render();
5279 float targetOpacity = 0.5f;
5280 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5281 float targetBorderlineWidth = 10.0f;
5282 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5283 float targetBorderlineOffset = -1.5f;
5285 Animation animation = Animation::New(1.0f);
5286 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5287 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5288 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5289 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5290 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5293 application.SendNotification();
5294 application.Render();
5295 application.Render(1001u); // End of animation
5297 Property::Map resultMap;
5298 svgVisual.CreatePropertyMap(resultMap);
5300 // Test property values: they should be updated
5301 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5302 DALI_TEST_CHECK(colorValue);
5303 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5305 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5306 DALI_TEST_CHECK(cornerRadiusValue);
5307 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5309 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5310 DALI_TEST_CHECK(borderlineWidthValue);
5311 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5313 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5314 DALI_TEST_CHECK(borderlineColorValue);
5315 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5317 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5318 DALI_TEST_CHECK(borderlineOffsetValue);
5319 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5321 // Currently test with multiple program doesn't work well. will fix another day
5322 // Test uniform value
5323 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5324 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5325 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5326 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5331 int UtcDaliVisualGetVisualProperty06(void)
5333 ToolkitTestApplication application;
5334 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5336 static std::vector<UniformData> customUniforms =
5338 UniformData("cornerRadius", Property::Type::VECTOR4),
5339 UniformData("borderlineWidth", Property::Type::FLOAT),
5340 UniformData("borderlineColor", Property::Type::VECTOR4),
5341 UniformData("borderlineOffset", Property::Type::FLOAT),
5344 TestGraphicsController& graphics = application.GetGraphicsController();
5345 graphics.AddCustomUniforms(customUniforms);
5347 VisualFactory factory = VisualFactory::Get();
5348 Property::Map propertyMap;
5349 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5350 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5352 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5354 DummyControl dummyControl = DummyControl::New(true);
5355 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5356 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5357 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5358 application.GetScene().Add(dummyControl);
5360 application.SendNotification();
5361 application.Render();
5363 // Wait for image loading
5364 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5366 application.SendNotification();
5367 application.Render();
5369 float targetOpacity = 0.5f;
5370 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5371 float targetBorderlineWidth = 10.0f;
5372 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5373 float targetBorderlineOffset = -1.5f;
5375 Animation animation = Animation::New(1.0f);
5376 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5377 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5378 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5379 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5380 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5383 application.SendNotification();
5384 application.Render();
5385 application.Render(1001u); // End of animation
5387 Property::Map resultMap;
5388 animatedImageVisual.CreatePropertyMap(resultMap);
5390 // Test property values: they should be updated
5391 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5392 DALI_TEST_CHECK(colorValue);
5393 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5395 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5396 DALI_TEST_CHECK(cornerRadiusValue);
5397 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5399 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5400 DALI_TEST_CHECK(borderlineWidthValue);
5401 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5403 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5404 DALI_TEST_CHECK(borderlineColorValue);
5405 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5407 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5408 DALI_TEST_CHECK(borderlineOffsetValue);
5409 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5411 // Currently test with multiple program doesn't work well. will fix another day
5412 // Test uniform value
5413 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5414 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5415 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5416 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5421 int UtcDaliVisualGetVisualProperty07(void)
5423 ToolkitTestApplication application;
5424 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5426 static std::vector<UniformData> customUniforms =
5428 UniformData("cornerRadius", Property::Type::VECTOR4),
5429 UniformData("borderlineWidth", Property::Type::FLOAT),
5430 UniformData("borderlineColor", Property::Type::VECTOR4),
5431 UniformData("borderlineOffset", Property::Type::FLOAT),
5434 TestGraphicsController& graphics = application.GetGraphicsController();
5435 graphics.AddCustomUniforms(customUniforms);
5437 VisualFactory factory = VisualFactory::Get();
5438 Property::Map propertyMap;
5439 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5440 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5442 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5444 DummyControl dummyControl = DummyControl::New(true);
5445 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5446 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5447 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5448 application.GetScene().Add(dummyControl);
5450 application.SendNotification();
5451 application.Render();
5453 // Wait for image loading
5454 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5456 application.SendNotification();
5457 application.Render();
5459 float targetOpacity = 0.5f;
5460 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5461 float targetBorderlineWidth = 10.0f;
5462 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5463 float targetBorderlineOffset = -1.5f;
5465 Animation animation = Animation::New(1.0f);
5466 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5467 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5468 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5469 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5470 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5473 application.SendNotification();
5474 application.Render();
5475 application.Render(1001u); // End of animation
5477 Property::Map resultMap;
5478 animatedVectorVisual.CreatePropertyMap(resultMap);
5480 // Test property values: they should be updated
5481 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5482 DALI_TEST_CHECK(colorValue);
5483 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5485 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5486 DALI_TEST_CHECK(cornerRadiusValue);
5487 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5489 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5490 DALI_TEST_CHECK(borderlineWidthValue);
5491 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5493 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5494 DALI_TEST_CHECK(borderlineColorValue);
5495 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5497 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5498 DALI_TEST_CHECK(borderlineOffsetValue);
5499 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5501 // Currently test with multiple program doesn't work well. will fix another day
5502 // Test uniform value
5503 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5504 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5505 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5506 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5511 int UtcDaliVisualUpdateProperty(void)
5513 ToolkitTestApplication application;
5514 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5516 VisualFactory factory = VisualFactory::Get();
5517 Property::Map propertyMap;
5518 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5519 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5520 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5521 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5523 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5525 DummyControl dummyControl = DummyControl::New(true);
5526 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5527 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5528 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5529 application.GetScene().Add(dummyControl);
5531 application.SendNotification();
5532 application.Render();
5534 // Wait for image loading
5535 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5537 application.SendNotification();
5538 application.Render();
5540 Property::Map originalMap;
5541 imageVisual.CreatePropertyMap(originalMap);
5543 float targetOpacity = 0.5f;
5544 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5545 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5546 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5548 Property::Map targetPropertyMap;
5549 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5550 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5551 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5552 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5553 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5555 // Update Properties
5556 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5558 Property::Map resultMap;
5559 imageVisual.CreatePropertyMap(resultMap);
5561 // Test property values: they should be updated
5562 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5563 DALI_TEST_CHECK(colorValue);
5564 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5566 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5567 DALI_TEST_CHECK(urlValue);
5568 // NOTE : ImageVisual URL must NOT changed.
5569 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5571 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5572 DALI_TEST_CHECK(preMultipliedValue);
5573 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5575 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5576 DALI_TEST_CHECK(visualFittingModeValue);
5577 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5582 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5584 ToolkitTestApplication application;
5585 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5587 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5589 VisualFactory factory = VisualFactory::Get();
5590 Property::Map propertyMap;
5592 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5593 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5595 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5597 DummyControl dummyControl = DummyControl::New(true);
5598 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5599 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5600 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5601 application.GetScene().Add(dummyControl);
5603 application.SendNotification();
5604 application.Render();
5606 // Wait for image loading
5607 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5609 application.SendNotification();
5610 application.Render();
5614 Renderer renderer = dummyControl.GetRendererAt(0);
5615 Shader shader = renderer.GetShader();
5616 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5617 Property::Map* map = value.GetMap();
5618 DALI_TEST_CHECK(map);
5620 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5621 DALI_TEST_CHECK(fragment);
5622 std::string fragmentShader;
5623 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5624 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5625 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5627 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5628 std::string vertexShader;
5629 DALI_TEST_CHECK(vertex->Get(vertexShader));
5630 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5631 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5634 callStack.Enable(true);
5636 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5638 Property::Map targetPropertyMap;
5639 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5640 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5642 // Update Properties with CornerRadius
5643 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5645 Property::Map resultMap;
5646 imageVisual.CreatePropertyMap(resultMap);
5648 // Test property values: they should be updated
5649 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5650 DALI_TEST_CHECK(cornerRadiusValue);
5651 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5653 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5654 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5655 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5659 Renderer renderer = dummyControl.GetRendererAt(0);
5660 Shader shader = renderer.GetShader();
5661 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5662 Property::Map* map = value.GetMap();
5663 DALI_TEST_CHECK(map);
5665 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5666 DALI_TEST_CHECK(fragment);
5667 std::string fragmentShader;
5668 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5669 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5670 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5672 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5673 std::string vertexShader;
5674 DALI_TEST_CHECK(vertex->Get(vertexShader));
5675 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5676 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5679 // Send shader compile signal
5680 application.SendNotification();
5681 application.Render();
5683 callStack.Enable(false);
5685 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5687 callStack.Enable(true);
5689 float targetBorderlineWidth = 10.0f;
5690 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5691 float targetBorderlineOffset = -0.3f;
5693 Property::Map targetPropertyMap2;
5694 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5695 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5696 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5697 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5698 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5700 // Update Properties with Borderline
5701 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5703 Property::Map resultMap2;
5704 imageVisual.CreatePropertyMap(resultMap2);
5706 // Test property values: they should be updated
5707 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5708 DALI_TEST_CHECK(cornerRadiusValue);
5709 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5711 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5712 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5713 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5715 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5716 DALI_TEST_CHECK(borderlineWidthValue);
5717 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5719 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5720 DALI_TEST_CHECK(borderlineColorValue);
5721 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5723 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5724 DALI_TEST_CHECK(borderlineOffsetValue);
5725 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5729 Renderer renderer = dummyControl.GetRendererAt(0);
5730 Shader shader = renderer.GetShader();
5731 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5732 Property::Map* map = value.GetMap();
5733 DALI_TEST_CHECK(map);
5735 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5736 DALI_TEST_CHECK(fragment);
5737 std::string fragmentShader;
5738 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5739 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5740 // Note : mAlwaysUsingCornerRadius is true.
5741 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5743 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5744 std::string vertexShader;
5745 DALI_TEST_CHECK(vertex->Get(vertexShader));
5746 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5747 // Note : mAlwaysUsingCornerRadius is true.
5748 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5751 // Send shader compile signal
5752 application.SendNotification();
5753 application.Render();
5755 callStack.Enable(false);
5757 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5759 callStack.Enable(true);
5761 Property::Map targetPropertyMap3;
5762 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5763 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5764 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5765 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5766 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5768 // Update Properties into zero
5769 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5771 Property::Map resultMap3;
5772 imageVisual.CreatePropertyMap(resultMap3);
5774 // Test property values: they should be updated
5775 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5776 DALI_TEST_CHECK(cornerRadiusValue);
5777 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5779 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5780 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5781 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5783 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5784 DALI_TEST_CHECK(borderlineWidthValue);
5785 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5787 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5788 DALI_TEST_CHECK(borderlineColorValue);
5789 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5791 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5792 DALI_TEST_CHECK(borderlineOffsetValue);
5793 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5797 Renderer renderer = dummyControl.GetRendererAt(0);
5798 Shader shader = renderer.GetShader();
5799 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5800 Property::Map* map = value.GetMap();
5801 DALI_TEST_CHECK(map);
5803 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5804 DALI_TEST_CHECK(fragment);
5805 std::string fragmentShader;
5806 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5807 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5808 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5809 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5811 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5812 std::string vertexShader;
5813 DALI_TEST_CHECK(vertex->Get(vertexShader));
5814 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5815 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5816 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5819 // Send shader compile signal
5820 application.SendNotification();
5821 application.Render();
5823 callStack.Enable(false);
5824 // Shader not changed
5825 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5830 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5832 ToolkitTestApplication application;
5833 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5835 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5837 VisualFactory factory = VisualFactory::Get();
5838 Property::Map propertyMap;
5840 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5841 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5843 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5845 DummyControl dummyControl = DummyControl::New(true);
5846 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5847 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5848 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5849 application.GetScene().Add(dummyControl);
5851 application.SendNotification();
5852 application.Render();
5854 // Wait for image loading
5855 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5857 application.SendNotification();
5858 application.Render();
5862 Renderer renderer = dummyControl.GetRendererAt(0);
5863 Shader shader = renderer.GetShader();
5864 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5865 Property::Map* map = value.GetMap();
5866 DALI_TEST_CHECK(map);
5868 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5869 DALI_TEST_CHECK(fragment);
5870 std::string fragmentShader;
5871 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5872 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5873 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5875 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5876 std::string vertexShader;
5877 DALI_TEST_CHECK(vertex->Get(vertexShader));
5878 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5879 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5882 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5884 Property::Map targetPropertyMap;
5885 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5888 callStack.Enable(true);
5890 // Update Properties with CornerRadius
5891 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5893 Property::Map resultMap;
5894 imageVisual.CreatePropertyMap(resultMap);
5896 // Test property values: they should be updated
5897 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5898 DALI_TEST_CHECK(cornerRadiusValue);
5899 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5903 Renderer renderer = dummyControl.GetRendererAt(0);
5904 Shader shader = renderer.GetShader();
5905 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5906 Property::Map* map = value.GetMap();
5907 DALI_TEST_CHECK(map);
5909 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5910 DALI_TEST_CHECK(fragment);
5911 std::string fragmentShader;
5912 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5913 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5914 // Note : corner radius is zero. so we don't change shader!
5915 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5917 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5918 std::string vertexShader;
5919 DALI_TEST_CHECK(vertex->Get(vertexShader));
5920 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5921 // Note : corner radius is zero. so we don't change shader!
5922 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5925 // Send shader compile signal
5926 application.SendNotification();
5927 application.Render();
5929 callStack.Enable(false);
5931 // Shader doesn't changed
5932 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5934 callStack.Enable(true);
5936 float targetBorderlineWidth = 0.0f;
5937 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5938 float targetBorderlineOffset = -1.0f;
5940 Property::Map targetPropertyMap2;
5941 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5942 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5943 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5945 // Update Properties with Borderline
5946 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5948 Property::Map resultMap2;
5949 imageVisual.CreatePropertyMap(resultMap2);
5951 // Test property values: they should be updated
5952 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5953 DALI_TEST_CHECK(borderlineWidthValue);
5954 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5956 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5957 DALI_TEST_CHECK(borderlineColorValue);
5958 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5960 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5961 DALI_TEST_CHECK(borderlineOffsetValue);
5962 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5966 Renderer renderer = dummyControl.GetRendererAt(0);
5967 Shader shader = renderer.GetShader();
5968 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5969 Property::Map* map = value.GetMap();
5970 DALI_TEST_CHECK(map);
5972 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5973 DALI_TEST_CHECK(fragment);
5974 std::string fragmentShader;
5975 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5976 // Note : borderline width is zero. so we don't change shader!
5977 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5978 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5980 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5981 std::string vertexShader;
5982 DALI_TEST_CHECK(vertex->Get(vertexShader));
5983 // Note : borderline width is zero. so we don't change shader!
5984 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5985 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5988 // Send shader compile signal
5989 application.SendNotification();
5990 application.Render();
5992 callStack.Enable(false);
5994 // Shader doesn't changed
5995 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6000 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6002 ToolkitTestApplication application;
6003 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6005 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6007 VisualFactory factory = VisualFactory::Get();
6008 Property::Map propertyMap;
6010 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6011 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6013 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6015 DummyControl dummyControl = DummyControl::New(true);
6016 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6017 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6018 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6019 application.GetScene().Add(dummyControl);
6021 application.SendNotification();
6022 application.Render();
6024 application.SendNotification();
6025 application.Render();
6029 Renderer renderer = dummyControl.GetRendererAt(0);
6030 Shader shader = renderer.GetShader();
6031 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6032 Property::Map* map = value.GetMap();
6033 DALI_TEST_CHECK(map);
6035 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6036 DALI_TEST_CHECK(fragment);
6037 std::string fragmentShader;
6038 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6039 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6040 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6041 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6043 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6044 std::string vertexShader;
6045 DALI_TEST_CHECK(vertex->Get(vertexShader));
6046 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6047 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6048 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6051 float targetBlurRadius = 15.0f;
6052 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6054 Property::Map targetPropertyMap;
6055 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6056 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6057 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6060 callStack.Enable(true);
6062 // Update Properties with CornerRadius
6063 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6065 Property::Map resultMap;
6066 imageVisual.CreatePropertyMap(resultMap);
6068 // Test property values: they should be updated
6069 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6070 DALI_TEST_CHECK(blurRadiusValue);
6071 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6073 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6074 DALI_TEST_CHECK(cornerRadiusValue);
6075 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6079 Renderer renderer = dummyControl.GetRendererAt(0);
6080 Shader shader = renderer.GetShader();
6081 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6082 Property::Map* map = value.GetMap();
6083 DALI_TEST_CHECK(map);
6085 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6086 DALI_TEST_CHECK(fragment);
6087 std::string fragmentShader;
6088 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6089 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6090 // Note : We ignore borderline when blur radius occured
6091 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6092 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6094 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6095 std::string vertexShader;
6096 DALI_TEST_CHECK(vertex->Get(vertexShader));
6097 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6098 // Note : We ignore borderline when blur radius occured
6099 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6100 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6103 // Send shader compile signal
6104 application.SendNotification();
6105 application.Render();
6107 callStack.Enable(false);
6110 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6112 callStack.Enable(true);
6114 Property::Map targetPropertyMap2;
6115 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6116 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6117 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6119 // Update Properties with CornerRadius
6120 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6122 Property::Map resultMap2;
6123 imageVisual.CreatePropertyMap(resultMap2);
6125 // Test property values: they should be updated
6126 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6127 DALI_TEST_CHECK(blurRadiusValue);
6128 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6130 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6131 DALI_TEST_CHECK(cornerRadiusValue);
6132 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6136 Renderer renderer = dummyControl.GetRendererAt(0);
6137 Shader shader = renderer.GetShader();
6138 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6139 Property::Map* map = value.GetMap();
6140 DALI_TEST_CHECK(map);
6142 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6143 DALI_TEST_CHECK(fragment);
6144 std::string fragmentShader;
6145 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6146 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6147 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6148 // Note : We ignore borderline when blur radius occured
6149 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6150 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6152 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6153 std::string vertexShader;
6154 DALI_TEST_CHECK(vertex->Get(vertexShader));
6155 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6156 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6157 // Note : We ignore borderline when blur radius occured
6158 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6159 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6162 // Send shader compile signal
6163 application.SendNotification();
6164 application.Render();
6166 callStack.Enable(false);
6168 // Shader not changed
6169 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6174 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6176 ToolkitTestApplication application;
6177 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6179 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6181 VisualFactory factory = VisualFactory::Get();
6182 Property::Map propertyMap;
6184 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6185 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6186 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6188 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6190 DummyControl dummyControl = DummyControl::New(true);
6191 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6192 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6193 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6194 application.GetScene().Add(dummyControl);
6196 application.SendNotification();
6197 application.Render();
6199 // Wait for image loading
6200 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6202 application.SendNotification();
6203 application.Render();
6207 Renderer renderer = dummyControl.GetRendererAt(0);
6208 Shader shader = renderer.GetShader();
6209 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6210 Property::Map* map = value.GetMap();
6211 DALI_TEST_CHECK(map);
6213 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6214 DALI_TEST_CHECK(fragment);
6215 std::string fragmentShader;
6216 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6217 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6218 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6220 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6221 std::string vertexShader;
6222 DALI_TEST_CHECK(vertex->Get(vertexShader));
6223 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6224 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6227 callStack.Enable(true);
6229 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6231 Animation animation = Animation::New(1.0f);
6232 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6235 application.SendNotification();
6236 application.Render();
6237 application.Render(1001u); // End of animation
6241 Renderer renderer = dummyControl.GetRendererAt(0);
6242 Shader shader = renderer.GetShader();
6243 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6244 Property::Map* map = value.GetMap();
6245 DALI_TEST_CHECK(map);
6247 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6248 DALI_TEST_CHECK(fragment);
6249 std::string fragmentShader;
6250 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6251 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6252 // Note : mAlwaysUsingCornerRadius is true.
6253 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6255 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6256 std::string vertexShader;
6257 DALI_TEST_CHECK(vertex->Get(vertexShader));
6258 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6259 // Note : mAlwaysUsingCornerRadius is true.
6260 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6262 callStack.Enable(false);
6263 // Shader not changed
6264 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6266 callStack.Enable(true);
6268 float targetBorderlineWidth = 10.0f;
6269 Property::Map targetPropertyMap;
6270 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6272 // Update Properties with CornerRadius
6273 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6275 Property::Map resultMap;
6276 imageVisual.CreatePropertyMap(resultMap);
6278 // Test property values: they should be updated
6279 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6280 DALI_TEST_CHECK(cornerRadiusValue);
6281 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6283 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6284 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6285 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6287 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6288 DALI_TEST_CHECK(borderlineWidthValue);
6289 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6293 Renderer renderer = dummyControl.GetRendererAt(0);
6294 Shader shader = renderer.GetShader();
6295 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6296 Property::Map* map = value.GetMap();
6297 DALI_TEST_CHECK(map);
6299 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6300 DALI_TEST_CHECK(fragment);
6301 std::string fragmentShader;
6302 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6303 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6304 // Note : mAlwaysUsingCornerRadius is true.
6305 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6307 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6308 std::string vertexShader;
6309 DALI_TEST_CHECK(vertex->Get(vertexShader));
6310 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6311 // Note : mAlwaysUsingCornerRadius is true.
6312 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6315 // Send shader compile signal
6316 application.SendNotification();
6317 application.Render();
6319 callStack.Enable(false);
6321 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));