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);
445 // Wait for loading & rasterization
446 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
448 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
449 Renderer renderer = actor.GetRendererAt(0);
450 auto textures = renderer.GetTextures();
451 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
453 application.GetScene().Remove(actor);
455 application.SendNotification();
456 application.Render(0);
457 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
460 application.GetScene().Add(actor);
462 application.SendNotification();
463 application.Render(0);
464 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
465 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
466 renderer = actor.GetRendererAt(0);
467 textures = renderer.GetTextures();
468 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
470 application.GetScene().Remove(actor);
472 application.SendNotification();
473 application.Render(0);
474 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
479 int UtcDaliVisualGetPropertyMap1(void)
481 ToolkitTestApplication application;
482 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
484 VisualFactory factory = VisualFactory::Get();
485 Property::Map propertyMap;
486 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
487 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
488 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
489 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
490 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
491 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
492 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
493 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
494 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
496 Property::Map resultMap;
497 colorVisual.CreatePropertyMap(resultMap);
499 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
500 DALI_TEST_CHECK(typeValue);
501 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
503 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
504 DALI_TEST_CHECK(colorValue);
505 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
507 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
508 DALI_TEST_CHECK(cornerRadiusValue);
509 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
511 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
512 DALI_TEST_CHECK(cornerRadiusPolicyValue);
513 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
515 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
516 DALI_TEST_CHECK(borderlineWidthValue);
517 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
519 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
520 DALI_TEST_CHECK(borderlineColorValue);
521 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
523 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
524 DALI_TEST_CHECK(borderlineOffsetValue);
525 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
527 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
528 DALI_TEST_CHECK(blurRadiusValue);
529 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
531 // change the blend color
532 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
533 colorVisual = factory.CreateVisual(propertyMap);
534 colorVisual.CreatePropertyMap(resultMap);
536 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
537 DALI_TEST_CHECK(colorValue);
538 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
541 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
543 colorVisual = factory.CreateVisual(propertyMap);
544 colorVisual.CreatePropertyMap(resultMap);
546 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
547 DALI_TEST_CHECK(blurRadiusValue);
548 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
553 int UtcDaliVisualGetPropertyMap2(void)
555 ToolkitTestApplication application;
556 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
558 VisualFactory factory = VisualFactory::Get();
559 Property::Map propertyMap;
560 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
561 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
562 propertyMap.Insert("borderColor", Color::BLUE);
563 propertyMap.Insert("borderSize", 5.f);
564 propertyMap.Insert("antiAliasing", true);
565 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
567 Property::Map resultMap;
568 borderVisual.CreatePropertyMap(resultMap);
570 // check the property values from the returned map from visual
571 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
572 DALI_TEST_CHECK(typeValue);
573 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
575 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
576 DALI_TEST_CHECK(colorValue);
577 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
579 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
580 DALI_TEST_CHECK(sizeValue);
581 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
583 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
584 DALI_TEST_CHECK(AAValue);
585 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
587 Property::Map propertyMap1;
588 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
589 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
590 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
591 borderVisual = factory.CreateVisual(propertyMap1);
592 borderVisual.CreatePropertyMap(resultMap);
594 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
595 DALI_TEST_CHECK(typeValue);
596 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
598 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
599 DALI_TEST_CHECK(colorValue);
600 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
602 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
603 DALI_TEST_CHECK(sizeValue);
604 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
609 int UtcDaliVisualGetPropertyMap2N(void)
611 ToolkitTestApplication application;
612 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
614 VisualFactory factory = VisualFactory::Get();
615 Property::Map propertyMap;
616 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
617 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
619 tet_infoline("Test that the visual is created, with a default renderer");
620 DALI_TEST_CHECK(borderVisual);
622 DummyControl dummyControl = DummyControl::New(true);
623 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
624 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
625 application.GetScene().Add(dummyControl);
627 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
632 int UtcDaliVisualGetPropertyMap3(void)
634 ToolkitTestApplication application;
635 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
637 VisualFactory factory = VisualFactory::Get();
638 DALI_TEST_CHECK(factory);
640 Property::Map propertyMap;
641 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
643 Vector2 start(-1.f, -1.f);
644 Vector2 end(1.f, 1.f);
645 propertyMap.Insert("startPosition", start);
646 propertyMap.Insert("endPosition", end);
647 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
649 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
651 Property::Array stopColors;
652 stopColors.PushBack(Color::RED);
653 stopColors.PushBack(Color::GREEN);
654 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
656 float borderlineWidth = 4.0f;
657 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
658 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
659 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
661 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
663 Property::Map resultMap;
664 gradientVisual.CreatePropertyMap(resultMap);
666 // check the property values from the returned map from visual
667 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
668 DALI_TEST_CHECK(value);
669 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
671 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
672 DALI_TEST_CHECK(value);
673 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
675 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
676 DALI_TEST_CHECK(value);
677 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
679 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
680 DALI_TEST_CHECK(value);
681 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
683 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
684 DALI_TEST_CHECK(value);
685 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
687 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
688 DALI_TEST_CHECK(value);
689 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
691 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
692 DALI_TEST_CHECK(value);
693 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
695 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
696 DALI_TEST_CHECK(value);
697 Property::Array* offsetArray = value->GetArray();
698 DALI_TEST_CHECK(offsetArray->Count() == 2);
699 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
700 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
702 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
703 DALI_TEST_CHECK(value);
704 Property::Array* colorArray = value->GetArray();
705 DALI_TEST_CHECK(colorArray->Count() == 2);
706 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
707 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
712 int UtcDaliVisualGetPropertyMap4(void)
714 ToolkitTestApplication application;
715 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
717 VisualFactory factory = VisualFactory::Get();
718 DALI_TEST_CHECK(factory);
720 Property::Map propertyMap;
721 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
723 Vector2 center(100.f, 100.f);
724 float radius = 100.f;
725 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
726 propertyMap.Insert(GradientVisual::Property::CENTER, center);
727 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
728 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
730 Property::Array stopColors;
731 stopColors.PushBack(Color::RED);
732 stopColors.PushBack(Color::BLACK);
733 stopColors.PushBack(Color::GREEN);
734 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
736 float borderlineWidth = 8.0f;
737 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
738 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
739 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
741 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
742 DALI_TEST_CHECK(gradientVisual);
744 Property::Map resultMap;
745 gradientVisual.CreatePropertyMap(resultMap);
747 // check the property values from the returned map from visual
748 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
749 DALI_TEST_CHECK(value);
750 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
752 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
753 DALI_TEST_CHECK(value);
754 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
756 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
757 DALI_TEST_CHECK(value);
758 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
760 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
761 DALI_TEST_CHECK(value);
762 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
764 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
765 DALI_TEST_CHECK(value);
766 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
768 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
769 DALI_TEST_CHECK(value);
770 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
772 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
773 DALI_TEST_CHECK(value);
774 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
776 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
777 DALI_TEST_CHECK(value);
778 Property::Array* offsetArray = value->GetArray();
779 DALI_TEST_CHECK(offsetArray->Count() == 3);
780 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
781 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
782 // any stop value will be clamped to [0.0, 1.0];
783 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
785 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
786 DALI_TEST_CHECK(value);
787 Property::Array* colorArray = value->GetArray();
788 DALI_TEST_CHECK(colorArray->Count() == 3);
789 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
790 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
791 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
796 int UtcDaliVisualGetPropertyMap5(void)
798 ToolkitTestApplication application;
799 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
801 VisualFactory factory = VisualFactory::Get();
802 Property::Map propertyMap;
803 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
804 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
805 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
806 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
807 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
808 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
809 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
810 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
811 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
812 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
813 propertyMap.Insert("synchronousLoading", true);
815 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
816 DALI_TEST_CHECK(imageVisual);
818 Property::Map resultMap;
819 imageVisual.CreatePropertyMap(resultMap);
821 // check the property values from the returned map from visual
822 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
823 DALI_TEST_CHECK(value);
824 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
826 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
827 DALI_TEST_CHECK(value);
828 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
830 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
831 DALI_TEST_CHECK(value);
832 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
834 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
835 DALI_TEST_CHECK(value);
836 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
838 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
839 DALI_TEST_CHECK(value);
840 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
842 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
843 DALI_TEST_CHECK(value);
844 DALI_TEST_CHECK(value->Get<int>() == 20);
846 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
847 DALI_TEST_CHECK(value);
848 DALI_TEST_CHECK(value->Get<int>() == 30);
850 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
851 DALI_TEST_CHECK(value);
852 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
854 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
855 DALI_TEST_CHECK(value);
856 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
858 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
859 DALI_TEST_CHECK(value);
860 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
862 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
863 DALI_TEST_CHECK(value);
864 DALI_TEST_CHECK(value->Get<bool>() == true);
869 int UtcDaliVisualGetPropertyMap6(void)
871 ToolkitTestApplication application;
872 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
874 Rect<int> border(1, 1, 1, 1);
876 VisualFactory factory = VisualFactory::Get();
877 Property::Map propertyMap;
878 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
879 propertyMap.Insert("mixColor", Color::MAGENTA);
880 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
881 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
882 propertyMap.Insert(ImageVisual::Property::BORDER, border);
883 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
884 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
885 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
887 Property::Map resultMap;
888 nPatchVisual.CreatePropertyMap(resultMap);
890 // check the property values from the returned map from visual
891 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
892 DALI_TEST_CHECK(value);
893 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
895 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
896 DALI_TEST_CHECK(value);
897 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
899 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
900 DALI_TEST_CHECK(value);
901 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
903 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
904 DALI_TEST_CHECK(value);
905 DALI_TEST_CHECK(value->Get<bool>());
907 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
908 DALI_TEST_CHECK(value);
909 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
911 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
912 DALI_TEST_CHECK(value);
913 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
915 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
916 DALI_TEST_CHECK(value);
917 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
919 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
921 Property::Map propertyMap1;
922 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
923 propertyMap1.Insert("mixColor", Color::MAGENTA);
924 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
925 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
926 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
927 nPatchVisual = factory.CreateVisual(propertyMap1);
929 nPatchVisual.CreatePropertyMap(resultMap);
931 // check the property values from the returned map from visual
932 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
933 DALI_TEST_CHECK(value);
934 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
936 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
937 DALI_TEST_CHECK(value);
938 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
940 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
941 DALI_TEST_CHECK(value);
942 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
944 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
945 DALI_TEST_CHECK(value);
946 DALI_TEST_CHECK(value->Get<bool>());
948 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
949 DALI_TEST_CHECK(value);
950 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
955 int UtcDaliVisualGetPropertyMap7(void)
957 ToolkitTestApplication application;
958 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
960 // request SvgVisual with a property map
961 VisualFactory factory = VisualFactory::Get();
962 Property::Map propertyMap;
963 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
964 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
965 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
966 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
967 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
969 Property::Map resultMap;
970 svgVisual.CreatePropertyMap(resultMap);
971 // check the property values from the returned map from a visual
972 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
973 DALI_TEST_CHECK(value);
974 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
976 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
977 DALI_TEST_CHECK(value);
978 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
980 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
981 DALI_TEST_CHECK(value);
982 DALI_TEST_CHECK(value->Get<bool>() == false);
984 // request SvgVisual with a property map 2
986 propertyMap["visualType"] = Visual::SVG;
987 propertyMap["mixColor"] = Color::WHITE;
988 propertyMap["url"] = TEST_SVG_FILE_NAME;
989 propertyMap["atlasing"] = true;
990 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
993 svgVisual1.CreatePropertyMap(resultMap);
994 // check the property values from the returned map from a visual
995 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
996 DALI_TEST_CHECK(value);
997 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
999 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1000 DALI_TEST_CHECK(value);
1001 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1003 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1004 DALI_TEST_CHECK(value);
1005 DALI_TEST_CHECK(value->Get<bool>() == true);
1007 // request SvgVisual with an URL
1008 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1010 svgVisual2.CreatePropertyMap(resultMap);
1011 // check the property values from the returned map from a visual
1012 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1013 DALI_TEST_CHECK(value);
1014 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1016 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1017 DALI_TEST_CHECK(value);
1018 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1024 int UtcDaliVisualGetPropertyMap8(void)
1026 ToolkitTestApplication application;
1027 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1029 //Request MeshVisual using a property map.
1030 VisualFactory factory = VisualFactory::Get();
1031 Property::Map propertyMap;
1032 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1033 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1034 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1035 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1036 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1037 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1038 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1039 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1041 Property::Map resultMap;
1042 meshVisual.CreatePropertyMap(resultMap);
1043 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1045 //Check values in the result map are identical to the initial map's values.
1046 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1047 DALI_TEST_CHECK(value);
1048 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1050 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1051 DALI_TEST_CHECK(value);
1052 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1054 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1055 DALI_TEST_CHECK(value);
1056 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1058 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1059 DALI_TEST_CHECK(value);
1060 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1062 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1063 DALI_TEST_CHECK(value);
1064 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1066 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1067 DALI_TEST_CHECK(value);
1068 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1073 //Primitive shape visual
1074 int UtcDaliVisualGetPropertyMap9(void)
1076 ToolkitTestApplication application;
1077 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1079 static std::vector<UniformData> customUniforms =
1081 UniformData("mixColor", Property::Type::VECTOR3),
1084 TestGraphicsController& graphics = application.GetGraphicsController();
1085 graphics.AddCustomUniforms(customUniforms);
1087 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1088 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1090 //Request PrimitiveVisual using a property map.
1091 VisualFactory factory = VisualFactory::Get();
1092 Property::Map propertyMap;
1093 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1094 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1095 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1096 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1097 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1098 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1099 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1100 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1101 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1102 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1103 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1104 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1105 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1106 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1108 Property::Map resultMap;
1109 primitiveVisual.CreatePropertyMap(resultMap);
1111 //Check values in the result map are identical to the initial map's values.
1112 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1113 DALI_TEST_CHECK(value);
1114 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1116 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1117 DALI_TEST_CHECK(value);
1118 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1120 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1121 DALI_TEST_CHECK(value);
1122 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1123 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1125 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1126 DALI_TEST_CHECK(value);
1127 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1129 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1130 DALI_TEST_CHECK(value);
1131 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1133 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1134 DALI_TEST_CHECK(value);
1135 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1137 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1138 DALI_TEST_CHECK(value);
1139 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1141 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1142 DALI_TEST_CHECK(value);
1143 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1145 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1146 DALI_TEST_CHECK(value);
1147 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1149 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1150 DALI_TEST_CHECK(value);
1151 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1153 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1154 DALI_TEST_CHECK(value);
1155 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1157 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1158 DALI_TEST_CHECK(value);
1159 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1161 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1162 DALI_TEST_CHECK(value);
1163 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1165 DummyControl actor = DummyControl::New(true);
1166 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1167 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1168 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1169 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1170 application.GetScene().Add(actor);
1172 Animation animation = Animation::New(1.0f);
1173 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1175 application.SendNotification();
1176 application.Render(0);
1177 application.Render(1000);
1178 application.SendNotification();
1180 auto& gl = application.GetGlAbstraction();
1181 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1183 tet_infoline("Check property map after animation");
1185 primitiveVisual.CreatePropertyMap(resultMap);
1186 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1187 DALI_TEST_CHECK(value);
1188 color = value->Get<Vector4>();
1189 // Ignore alpha part
1190 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1196 int UtcDaliVisualGetPropertyMap10(void)
1198 ToolkitTestApplication application;
1199 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1201 //Request PrimitiveVisual using a property map.
1202 VisualFactory factory = VisualFactory::Get();
1204 Property::Map propertyMap;
1205 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1206 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1207 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1208 propertyMap.Insert("enableMarkup", false);
1209 propertyMap.Insert("text", "Hello world");
1210 propertyMap.Insert("fontFamily", "TizenSans");
1212 Property::Map fontStyleMapSet;
1213 fontStyleMapSet.Insert("weight", "bold");
1214 propertyMap.Insert("fontStyle", fontStyleMapSet);
1216 propertyMap.Insert("pointSize", 12.f);
1217 propertyMap.Insert("multiLine", true);
1218 propertyMap.Insert("horizontalAlignment", "CENTER");
1219 propertyMap.Insert("verticalAlignment", "CENTER");
1220 propertyMap.Insert("textColor", Color::RED);
1222 Property::Map shadowMapSet;
1223 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1225 Property::Map underlineMapSet;
1226 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));
1228 Property::Map outlineMapSet;
1229 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1231 Property::Map backgroundMapSet;
1232 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1234 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1236 Property::Map resultMap;
1237 textVisual.CreatePropertyMap(resultMap);
1239 //Check values in the result map are identical to the initial map's values.
1240 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1241 DALI_TEST_CHECK(value);
1242 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1244 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1245 DALI_TEST_CHECK(value);
1246 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1248 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1249 DALI_TEST_CHECK(value);
1250 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1252 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1253 DALI_TEST_CHECK(value);
1254 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1256 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1257 DALI_TEST_CHECK(value);
1259 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1260 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1261 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1263 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1264 DALI_TEST_CHECK(value);
1265 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1267 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1268 DALI_TEST_CHECK(value);
1269 DALI_TEST_CHECK(value->Get<bool>());
1271 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1272 DALI_TEST_CHECK(value);
1273 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1275 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1276 DALI_TEST_CHECK(value);
1277 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1279 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1280 DALI_TEST_CHECK(value);
1281 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1283 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1284 DALI_TEST_CHECK(value);
1285 DALI_TEST_CHECK(!value->Get<bool>());
1287 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1288 DALI_TEST_CHECK(value);
1290 Property::Map shadowMapGet = value->Get<Property::Map>();
1291 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1292 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1294 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1295 DALI_TEST_CHECK(value);
1297 Property::Map underlineMapGet = value->Get<Property::Map>();
1298 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1299 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1301 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1302 DALI_TEST_CHECK(value);
1304 Property::Map outlineMapGet = value->Get<Property::Map>();
1305 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1306 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1308 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1309 DALI_TEST_CHECK(value);
1311 Property::Map backgroundMapGet = value->Get<Property::Map>();
1312 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1313 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1318 int UtcDaliVisualGetPropertyMap11(void)
1320 ToolkitTestApplication application;
1321 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1323 VisualFactory factory = VisualFactory::Get();
1324 DALI_TEST_CHECK(factory);
1326 Property::Map propertyMap;
1327 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1329 Vector2 start(-0.5f, 0.5f);
1330 Vector2 end(0.5f, -0.0f);
1331 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1332 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1333 Vector2 rotate_center(0.0f, 0.4f);
1334 float rotate_amount = 1.57f;
1335 float offset = 100.f;
1337 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1338 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1339 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1341 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1342 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1343 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1344 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1345 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1346 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1347 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1349 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1350 DALI_TEST_CHECK(animatedGradientVisual);
1352 Property::Map resultMap;
1353 animatedGradientVisual.CreatePropertyMap(resultMap);
1355 // check the property values from the returned map from visual
1356 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1357 DALI_TEST_CHECK(value);
1358 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1360 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1361 DALI_TEST_CHECK(value);
1362 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1364 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1365 DALI_TEST_CHECK(value);
1366 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1368 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1369 DALI_TEST_CHECK(value);
1370 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1372 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1373 DALI_TEST_CHECK(value);
1374 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1376 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1377 DALI_TEST_CHECK(value);
1378 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1380 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1381 DALI_TEST_CHECK(value);
1382 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1384 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1385 DALI_TEST_CHECK(value);
1386 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1388 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1389 DALI_TEST_CHECK(value);
1390 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1392 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1393 DALI_TEST_CHECK(value);
1394 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1396 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1397 DALI_TEST_CHECK(value);
1398 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1403 int UtcDaliVisualGetPropertyMap12(void)
1405 ToolkitTestApplication application;
1406 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1408 // Case 1 : Set values by index
1410 tet_printf(" - Set Values by Index\n");
1411 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1412 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1413 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1415 tet_printf("test with delay [%f]\n", _delay);
1416 VisualFactory factory = VisualFactory::Get();
1417 DALI_TEST_CHECK(factory);
1419 Property::Map propertyMap;
1420 Property::Map animationMap;
1421 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1423 float duration = 1.1f;
1424 float delay = _delay;
1425 float repeat_delay = 0.4f;
1427 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1429 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1430 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1432 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1433 animationMap.Clear();
1434 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1435 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1436 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1437 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1438 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1439 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1440 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1441 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1442 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1444 return animationMap;
1447 Vector2 start1(-0.5f, 0.5f);
1448 Vector2 end1(0.5f, -0.5f);
1449 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1450 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1451 Vector2 rotate_center1(0.0f, 0.4f);
1452 float rotate_amount1 = 0.0f;
1453 float offset1 = 0.f;
1455 Vector2 start2(-0.5f, -0.5f);
1456 Vector2 end2(0.5f, 0.5f);
1457 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1458 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1459 Vector2 rotate_center2(0.0f, -0.4f);
1460 float rotate_amount2 = 6.2832f;
1461 float offset2 = 2.f;
1463 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1464 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1465 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1467 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1468 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1469 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1470 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1471 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1472 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1473 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1475 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1476 DALI_TEST_CHECK(animatedGradientVisual);
1478 Property::Map resultMap;
1479 animatedGradientVisual.CreatePropertyMap(resultMap);
1481 // check the property values from the returned map from visual
1482 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1483 DALI_TEST_CHECK(value);
1484 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1486 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1487 DALI_TEST_CHECK(value);
1488 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1490 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1491 DALI_TEST_CHECK(value);
1492 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1494 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1495 DALI_TEST_CHECK(value);
1496 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1498 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 {
1499 tet_printf("Check value at %d\n", line_num);
1500 value = resultMap.Find(index, Property::MAP);
1501 DALI_TEST_CHECK(value);
1502 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1503 Property::Map* temp_map = value->GetMap();
1504 DALI_TEST_CHECK(temp_map);
1506 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1507 Property::Value* res = temp_map->Find(index);
1508 DALI_TEST_CHECK(res);
1512 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1513 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1514 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1515 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1516 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1517 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1518 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1519 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1520 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1523 // check the animation map data is good
1524 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1525 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1526 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1527 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1528 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1529 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1530 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1534 // Case 2 : Set values by string
1536 tet_printf(" - Set Values by String\n");
1537 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1538 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1539 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1541 tet_printf("test with delay [%f]\n", _delay);
1542 VisualFactory factory = VisualFactory::Get();
1543 DALI_TEST_CHECK(factory);
1545 Property::Map propertyMap;
1546 Property::Map animationMap;
1547 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1549 float duration = 1.1f;
1550 float delay = _delay;
1551 float repeat_delay = 0.4f;
1553 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1555 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1556 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1558 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1559 animationMap.Clear();
1560 animationMap.Insert("startValue", start);
1561 animationMap.Insert("targetValue", target);
1562 animationMap.Insert("directionType", "BACKWARD");
1563 animationMap.Insert("duration", duration);
1564 animationMap.Insert("delay", delay);
1565 animationMap.Insert("repeat", loop_count);
1566 animationMap.Insert("repeatDelay", repeat_delay);
1567 animationMap.Insert("motionType", "MIRROR");
1568 animationMap.Insert("easingType", "IN_OUT");
1570 return animationMap;
1573 Vector2 start1(-0.5f, 0.5f);
1574 Vector2 end1(0.5f, -0.5f);
1575 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1576 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1577 Vector2 rotate_center1(0.0f, 0.4f);
1578 float rotate_amount1 = 0.0f;
1579 float offset1 = 0.f;
1581 Vector2 start2(-0.5f, -0.5f);
1582 Vector2 end2(0.5f, 0.5f);
1583 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1584 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1585 Vector2 rotate_center2(0.0f, -0.4f);
1586 float rotate_amount2 = 6.2832f;
1587 float offset2 = 2.f;
1589 // For test mix the type string/index key and string/index value works well.
1590 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1591 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1592 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1594 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1595 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1596 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1597 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1598 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1599 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1600 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1602 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1603 DALI_TEST_CHECK(animatedGradientVisual);
1605 Property::Map resultMap;
1606 animatedGradientVisual.CreatePropertyMap(resultMap);
1608 // check the property values from the returned map from visual
1609 // Note : resultMap from CreatePropertyMap only contain indexKey
1610 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1611 DALI_TEST_CHECK(value);
1612 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1614 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1615 DALI_TEST_CHECK(value);
1616 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1618 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1619 DALI_TEST_CHECK(value);
1620 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1622 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1623 DALI_TEST_CHECK(value);
1624 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1626 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 {
1627 tet_printf("Check value at %d\n", line_num);
1628 value = resultMap.Find(index, Property::MAP);
1629 DALI_TEST_CHECK(value);
1630 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1631 Property::Map* temp_map = value->GetMap();
1632 DALI_TEST_CHECK(temp_map);
1634 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1635 Property::Value* res = temp_map->Find(index);
1636 DALI_TEST_CHECK(res);
1640 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1641 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1642 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1643 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1644 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1645 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1646 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1647 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1648 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1651 // check the animation map data is good
1652 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1653 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1654 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1655 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1656 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1657 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1658 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1664 int UtcDaliVisualGetPropertyMap13(void)
1666 ToolkitTestApplication application;
1667 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1669 for(int _direction = 0; _direction <= 1; ++_direction)
1671 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1673 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1674 VisualFactory factory = VisualFactory::Get();
1675 DALI_TEST_CHECK(factory);
1677 Property::Map propertyMap;
1678 Property::Map animationMap;
1679 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1681 float duration = 1.0f;
1682 float delay = _delay;
1683 float repeat_delay = 0.5f;
1685 int direction = _direction;
1686 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1687 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1688 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1690 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1691 animationMap.Clear();
1692 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1693 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1695 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1697 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1698 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1699 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1700 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1701 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1702 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1703 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1704 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1706 return animationMap;
1709 Vector2 start1(-0.5f, 0.5f);
1710 Vector2 end1(0.5f, -0.5f);
1711 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1712 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1713 Vector2 rotate_center1(1.0f, 0.4f);
1714 float rotate_amount1 = 2.0f;
1715 float offset1 = 1.f;
1717 Vector2 start2(-0.5f, -0.5f);
1718 Vector2 end2(0.5f, 0.5f);
1719 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1720 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1721 Vector2 rotate_center2(1.0f, -0.4f);
1722 float rotate_amount2 = 1.0f;
1723 float offset2 = 3.f;
1725 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1726 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1727 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1729 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1730 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1731 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1732 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1733 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1734 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1735 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1737 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1738 DALI_TEST_CHECK(animatedGradientVisual);
1740 Property::Map resultMap;
1741 animatedGradientVisual.CreatePropertyMap(resultMap);
1743 // check the property values from the returned map from visual
1744 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1745 DALI_TEST_CHECK(value);
1746 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1748 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1749 DALI_TEST_CHECK(value);
1750 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1752 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1753 DALI_TEST_CHECK(value);
1754 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1756 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1757 DALI_TEST_CHECK(value);
1758 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1760 // If loop_count = 0, Animation doesn't created.
1761 // Optimized resultMap only have one value, which is target value
1762 // Note: target value will be changed by direction option.
1763 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1764 DALI_TEST_CHECK(value);
1765 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1767 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1768 DALI_TEST_CHECK(value);
1769 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1771 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1772 DALI_TEST_CHECK(value);
1773 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1775 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1776 DALI_TEST_CHECK(value);
1777 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1779 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1780 DALI_TEST_CHECK(value);
1781 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1783 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1784 DALI_TEST_CHECK(value);
1785 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1787 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1788 DALI_TEST_CHECK(value);
1789 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1796 int UtcDaliVisualAnimateBorderVisual01(void)
1798 ToolkitTestApplication application;
1799 tet_infoline("UtcDaliAnimateBorderVisual Color");
1801 static std::vector<UniformData> customUniforms =
1803 UniformData("borderColor", Property::Type::VECTOR4),
1804 UniformData("mixColor", Property::Type::VECTOR3),
1807 TestGraphicsController& graphics = application.GetGraphicsController();
1808 graphics.AddCustomUniforms(customUniforms);
1810 VisualFactory factory = VisualFactory::Get();
1811 Property::Map propertyMap;
1812 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1813 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1814 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1815 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1816 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1819 map["target"] = "testVisual";
1820 map["property"] = "mixColor";
1821 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1822 map["animator"] = Property::Map()
1823 .Add("alphaFunction", "LINEAR")
1824 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1826 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1828 DummyControl actor = DummyControl::New(true);
1829 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1830 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1831 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1832 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1833 application.GetScene().Add(actor);
1835 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1837 Renderer renderer = actor.GetRendererAt(0);
1838 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1839 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1841 Animation animation = dummyImpl.CreateTransition(transition);
1843 // Animate the mix color through the transition, and the border color through
1844 // programmatic method.
1845 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1848 application.SendNotification();
1849 application.Render(0);
1850 application.Render(2000u); // halfway point between blue and white
1852 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1853 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1854 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1855 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1857 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1858 testColor = Vector4(1, 1, 1, 0.45f);
1859 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1860 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1863 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1864 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1866 application.Render(2000u);
1868 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1869 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1870 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1872 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1873 testColor = Vector4(1, 1, 1, 0.1);
1874 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1875 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1877 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1878 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1883 int UtcDaliVisualAnimateBorderVisual02(void)
1885 ToolkitTestApplication application;
1886 tet_infoline("UtcDaliAnimateBorderVisual Size");
1888 static std::vector<UniformData> customUniforms =
1890 UniformData("borderSize", Property::Type::FLOAT),
1893 TestGraphicsController& graphics = application.GetGraphicsController();
1894 graphics.AddCustomUniforms(customUniforms);
1896 VisualFactory factory = VisualFactory::Get();
1897 Property::Map propertyMap;
1898 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1899 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1900 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1901 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1903 DummyControl actor = DummyControl::New(true);
1904 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1905 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1906 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1907 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1908 application.GetScene().Add(actor);
1910 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1912 Renderer renderer = actor.GetRendererAt(0);
1913 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1915 Animation animation = Animation::New(4.0f);
1916 animation.AnimateTo(Property(renderer, index), 9.0f);
1919 application.SendNotification();
1920 application.Render(0);
1921 application.Render(2000u); // halfway point
1923 float size = renderer.GetCurrentProperty<float>(index);
1924 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1925 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1927 application.Render(2000u); // halfway point between blue and white
1929 size = renderer.GetCurrentProperty<float>(index);
1930 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1931 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1936 int UtcDaliVisualAnimateColorVisual(void)
1938 ToolkitTestApplication application;
1939 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1941 static std::vector<UniformData> customUniforms =
1943 UniformData("mixColor", Property::Type::VECTOR3),
1946 TestGraphicsController& graphics = application.GetGraphicsController();
1947 graphics.AddCustomUniforms(customUniforms);
1949 VisualFactory factory = VisualFactory::Get();
1950 Property::Map propertyMap;
1951 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1952 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1953 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1955 DummyControl actor = DummyControl::New(true);
1956 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1957 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1958 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1959 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1960 application.GetScene().Add(actor);
1962 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1964 Renderer renderer = actor.GetRendererAt(0);
1965 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1967 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1968 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1970 Animation animation = Animation::New(4.0f);
1971 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1974 application.SendNotification();
1975 application.Render(0);
1976 application.Render(2000u); // halfway point
1978 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1979 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
1980 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1982 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1984 application.Render(2000u); // halfway point between blue and white
1986 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1987 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
1989 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
1991 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
1992 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1997 int UtcDaliVisualAnimatePrimitiveVisual(void)
1999 ToolkitTestApplication application;
2000 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2002 static std::vector<UniformData> customUniforms =
2004 UniformData("mixColor", Property::Type::VECTOR3),
2007 TestGraphicsController& graphics = application.GetGraphicsController();
2008 graphics.AddCustomUniforms(customUniforms);
2011 VisualFactory factory = VisualFactory::Get();
2012 Property::Map propertyMap;
2013 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2014 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2015 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2016 Visual::Base visual = factory.CreateVisual(propertyMap);
2018 DummyControl actor = DummyControl::New(true);
2019 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2020 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2021 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2022 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2023 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2024 application.GetScene().Add(actor);
2026 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2028 Renderer renderer = actor.GetRendererAt(0);
2030 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2031 const Vector4 TARGET_MIX_COLOR(Color::RED);
2034 map["target"] = "testVisual";
2035 map["property"] = "mixColor";
2036 map["initialValue"] = INITIAL_MIX_COLOR;
2037 map["targetValue"] = TARGET_MIX_COLOR;
2038 map["animator"] = Property::Map()
2039 .Add("alphaFunction", "LINEAR")
2040 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2042 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2044 Animation animation = dummyImpl.CreateTransition(transition);
2045 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2048 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2049 glAbstraction.EnableEnableDisableCallTrace(true);
2050 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2051 std::ostringstream blendStr;
2052 blendStr << std::hex << GL_BLEND;
2054 application.SendNotification();
2055 application.Render(0);
2056 application.Render(2000u); // halfway point
2057 application.SendNotification();
2059 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2060 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2061 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2063 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2065 glEnableStack.Reset();
2067 application.Render(2001u); // go past end
2068 application.SendNotification(); // Trigger signals
2070 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2071 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2072 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2074 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2082 int UtcDaliVisualAnimatedGradientVisual01(void)
2084 ToolkitTestApplication application;
2085 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2087 static std::vector<UniformData> customUniforms =
2089 UniformData("start_point", Property::Type::VECTOR2),
2090 UniformData("end_point", Property::Type::VECTOR2),
2091 UniformData("start_color", Property::Type::VECTOR4),
2092 UniformData("end_color", Property::Type::VECTOR4),
2093 UniformData("rotate_center", Property::Type::VECTOR2),
2094 UniformData("rotate_angle", Property::Type::FLOAT),
2095 UniformData("gradient_offset", Property::Type::FLOAT),
2098 TestGraphicsController& graphics = application.GetGraphicsController();
2099 graphics.AddCustomUniforms(customUniforms);
2102 VisualFactory factory = VisualFactory::Get();
2103 Property::Map propertyMap;
2104 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2105 Visual::Base visual = factory.CreateVisual(propertyMap);
2107 DummyControl actor = DummyControl::New(true);
2108 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2109 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2110 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2111 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2112 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2113 application.GetScene().Add(actor);
2115 application.SendNotification();
2116 application.Render(0);
2117 application.SendNotification();
2119 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2121 for(int step_iter = 0; step_iter < 3; step_iter++)
2123 application.SendNotification();
2124 application.Render(0);
2125 application.Render(750u); // step i/4
2126 application.SendNotification();
2128 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2129 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2130 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2131 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2132 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2133 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2134 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2137 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2138 application.Render(750u); // go to end
2139 application.SendNotification();
2141 application.Render(10u); // finish
2142 application.SendNotification();
2145 application.SendNotification();
2146 application.Render(0u);
2147 application.SendNotification();
2153 int UtcDaliVisualAnimatedGradientVisual02(void)
2155 ToolkitTestApplication application;
2156 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2158 static std::vector<UniformData> customUniforms =
2160 UniformData("start_point", Property::Type::VECTOR2),
2161 UniformData("end_point", Property::Type::VECTOR2),
2162 UniformData("start_color", Property::Type::VECTOR4),
2163 UniformData("end_color", Property::Type::VECTOR4),
2164 UniformData("rotate_center", Property::Type::VECTOR2),
2165 UniformData("rotate_angle", Property::Type::FLOAT),
2166 UniformData("gradient_offset", Property::Type::FLOAT),
2169 TestGraphicsController& graphics = application.GetGraphicsController();
2170 graphics.AddCustomUniforms(customUniforms);
2173 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
2174 int _direction[2] = {0, 1};
2175 int _loop_count[3] = {-1, 0, 1};
2176 int _motion[2] = {0, 1};
2177 int _easing[4] = {0, 1, 2, 3};
2179 int test_case_max = 4 * 2 * 3 * 2 * 4;
2181 int test_case_d = 7; // 7 is the number of animated properties.
2183 float _duration = 0.4f;
2184 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2185 float noise_maker = 0.0f;
2186 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2187 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2189 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2191 VisualFactory factory = VisualFactory::Get();
2192 Property::Map propertyMap;
2193 Property::Map animationMap;
2194 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2196 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2197 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2198 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2200 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& {
2201 int tc = (test_case + tc_offset);
2202 int idx_easing = tc % 4;
2204 int idx_motion = tc % 2;
2206 int idx_loop_count = tc % 3;
2208 int idx_direction = tc % 2;
2210 int idx_delay = tc % 4;
2213 float duration = _duration - _repeat_delay;
2214 float repeat_delay = _repeat_delay;
2215 float delay = _delay[idx_delay] * _duration;
2216 int direction = _direction[idx_direction];
2217 int loop_count = _loop_count[idx_loop_count];
2218 int motion = _motion[idx_motion];
2219 int easing = _easing[idx_easing];
2221 animationMap.Clear();
2222 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2223 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2226 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2230 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2232 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2233 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2234 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2235 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2238 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2242 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2246 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2248 else if(easing == 1)
2250 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2252 else if(easing == 2)
2254 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2258 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2261 return animationMap;
2264 // Give different values for debuging
2265 noise_maker += 1.0f;
2266 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2267 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2268 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2269 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2270 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2271 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2272 float offset1 = 0.f + noise_maker * 0.1f;
2274 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2275 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2276 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2277 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2278 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2279 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2280 float offset2 = 2.f + noise_maker * 0.1f;
2282 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2283 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2284 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2286 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2287 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2288 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2289 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2290 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2291 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2292 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2294 Visual::Base visual = factory.CreateVisual(propertyMap);
2296 DummyControl actor = DummyControl::New(true);
2297 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2298 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2299 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2300 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2301 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2302 application.GetScene().Add(actor);
2304 application.SendNotification();
2305 application.Render(0);
2306 application.SendNotification();
2308 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2310 application.SendNotification();
2312 //Compare between CPU calculated value and Shader Visual calculated value
2313 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 {
2314 int tc = (test_case + tc_offset);
2315 int idx_easing = tc % 4;
2317 int idx_motion = tc % 2;
2319 int idx_loop_count = tc % 3;
2321 int idx_direction = tc % 2;
2323 int idx_delay = tc % 4;
2326 float duration = _duration - _repeat_delay;
2327 float repeat_delay = _repeat_delay;
2328 float delay = _delay[idx_delay] * _duration;
2329 int direction = _direction[idx_direction];
2330 int loop_count = _loop_count[idx_loop_count];
2331 int motion = _motion[idx_motion];
2332 int easing = _easing[idx_easing];
2334 progress -= delay / _duration;
2336 Property::Value s = start;
2337 Property::Value t = target;
2343 float x; ///< Animator progress value
2348 else if(loop_count > 0 && progress + 0.01f > loop_count)
2350 x = (motion == 0) ? 1.0f : 0.0f;
2358 progress = fmodf(progress, 1.0f);
2359 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2364 x = progress * 2.0f;
2371 if(easing == 1) // EASE_IN
2375 else if(easing == 2) // EASE_OUT
2377 x = 2.0f * x - x * x;
2379 else if(easing == 3) // EASE_IN_OUT
2381 x = x * x * (3.0f - 2.0f * x);
2384 if(value_type == 0) // result type is Float
2388 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2389 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2390 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2392 else if(value_type == 1) // result type is Vector2
2396 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2397 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2398 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2400 else if(value_type == 2) // result type is Vector3
2404 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2405 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2406 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2408 else // result type is Vector4
2412 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2413 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2414 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2419 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2421 for(int step_iter = 0; step_iter < 3; step_iter++)
2423 application.SendNotification();
2424 application.Render(_duration * 250.f); // step i/4
2425 application.SendNotification();
2428 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2429 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2430 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2431 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2432 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2433 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2434 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2436 application.SendNotification();
2437 application.Render(_duration * 250.f); // step 4/4 will not test
2438 application.SendNotification();
2442 application.SendNotification();
2444 application.SendNotification();
2445 application.Render(10.f); // tempral time
2446 application.SendNotification();
2453 int UtcDaliVisualAnimatedGradientVisual03(void)
2455 ToolkitTestApplication application;
2456 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2458 static std::vector<UniformData> customUniforms =
2460 UniformData("start_point", Property::Type::VECTOR2),
2461 UniformData("end_point", Property::Type::VECTOR2),
2462 UniformData("start_color", Property::Type::VECTOR4),
2463 UniformData("end_color", Property::Type::VECTOR4),
2464 UniformData("rotate_center", Property::Type::VECTOR2),
2465 UniformData("rotate_angle", Property::Type::FLOAT),
2466 UniformData("gradient_offset", Property::Type::FLOAT),
2469 TestGraphicsController& graphics = application.GetGraphicsController();
2470 graphics.AddCustomUniforms(customUniforms);
2473 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
2474 int _direction[2] = {0, 1};
2475 int _loop_count[3] = {-1, 0, 1};
2476 int _motion[2] = {0, 1};
2477 int _easing[4] = {0, 1, 2, 3};
2479 int test_case_max = 4 * 2 * 3 * 2 * 4;
2481 int test_case_d = 7; // 7 is the number of animated properties.
2483 float _duration = 0.4f;
2484 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2485 float noise_maker = 0.2f;
2486 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2487 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2489 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2491 VisualFactory factory = VisualFactory::Get();
2492 Property::Map propertyMap;
2493 Property::Map animationMap;
2494 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2496 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& {
2497 int tc = (test_case + tc_offset);
2498 int idx_easing = tc % 4;
2500 int idx_motion = tc % 2;
2502 int idx_loop_count = tc % 3;
2504 int idx_direction = tc % 2;
2506 int idx_delay = tc % 4;
2509 float duration = _duration - _repeat_delay;
2510 float repeat_delay = _repeat_delay;
2511 float delay = _delay[idx_delay] * _duration;
2512 int direction = _direction[idx_direction];
2513 int loop_count = _loop_count[idx_loop_count];
2514 int motion = _motion[idx_motion];
2515 int easing = _easing[idx_easing];
2517 animationMap.Clear();
2518 animationMap.Insert("startValue", start);
2519 animationMap.Insert("targetValue", target);
2522 animationMap.Insert("directionType", "FORWARD");
2526 animationMap.Insert("directionType", "BACKWARD");
2528 animationMap.Insert("duration", duration);
2529 animationMap.Insert("delay", delay);
2530 animationMap.Insert("repeat", loop_count);
2531 animationMap.Insert("repeatDelay", repeat_delay);
2534 animationMap.Insert("motionType", "LOOP");
2538 animationMap.Insert("motionType", "MIRROR");
2542 animationMap.Insert("easingType", "LINEAR");
2544 else if(easing == 1)
2546 animationMap.Insert("easingType", "IN");
2548 else if(easing == 2)
2550 animationMap.Insert("easingType", "OUT");
2554 animationMap.Insert("easingType", "IN_OUT");
2557 return animationMap;
2560 // Give different values for debuging
2561 noise_maker += 0.8f;
2562 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2563 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2564 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2565 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2566 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2567 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2568 float offset1 = 0.f + noise_maker * 0.1f;
2570 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2571 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2572 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2573 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2574 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2575 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2576 float offset2 = 2.f + noise_maker * 0.1f;
2578 propertyMap.Insert("gradientType", "LINEAR");
2579 propertyMap.Insert("unitType", "USER_SPACE");
2580 propertyMap.Insert("spreadType", "CLAMP");
2582 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2583 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2584 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2585 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2586 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2587 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2588 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2590 Visual::Base visual = factory.CreateVisual(propertyMap);
2592 DummyControl actor = DummyControl::New(true);
2593 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2594 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2595 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2596 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2597 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2598 application.GetScene().Add(actor);
2600 application.SendNotification();
2601 application.Render(0);
2602 application.SendNotification();
2604 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2606 application.SendNotification();
2608 //Compare between CPU calculated value and Shader Visual calculated value
2609 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 {
2610 int tc = (test_case + tc_offset);
2611 int idx_easing = tc % 4;
2613 int idx_motion = tc % 2;
2615 int idx_loop_count = tc % 3;
2617 int idx_direction = tc % 2;
2619 int idx_delay = tc % 4;
2622 float duration = _duration - _repeat_delay;
2623 float repeat_delay = _repeat_delay;
2624 float delay = _delay[idx_delay] * _duration;
2625 int direction = _direction[idx_direction];
2626 int loop_count = _loop_count[idx_loop_count];
2627 int motion = _motion[idx_motion];
2628 int easing = _easing[idx_easing];
2630 progress -= delay / _duration;
2632 Property::Value s = start;
2633 Property::Value t = target;
2639 float x; ///< Animator progress value
2644 else if(loop_count > 0 && progress + 0.01f > loop_count)
2646 x = (motion == 0) ? 1.0f : 0.0f;
2654 progress = fmodf(progress, 1.0f);
2655 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2660 x = progress * 2.0f;
2667 if(easing == 1) // EASE_IN
2671 else if(easing == 2) // EASE_OUT
2673 x = 2.0f * x - x * x;
2675 else if(easing == 3) // EASE_IN_OUT
2677 x = x * x * (3.0f - 2.0f * x);
2680 if(value_type == 0) // result type is Float
2684 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2685 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2686 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2688 else if(value_type == 1) // result type is Vector2
2692 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2693 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2694 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2696 else if(value_type == 2) // result type is Vector3
2700 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2701 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2702 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2704 else // result type is Vector4
2708 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2709 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2710 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2715 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2717 for(int step_iter = 0; step_iter < 3; step_iter++)
2719 application.SendNotification();
2720 application.Render(_duration * 250.f); // step i/4
2721 application.SendNotification();
2724 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2725 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2726 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2727 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2728 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2729 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2730 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2732 application.SendNotification();
2733 application.Render(_duration * 250.f); // step 4/4 will not test
2734 application.SendNotification();
2738 application.SendNotification();
2740 application.SendNotification();
2741 application.Render(10.f); // tempral time
2742 application.SendNotification();
2749 int UtcDaliVisualWireframeVisual(void)
2751 ToolkitTestApplication application;
2753 VisualFactory factory = VisualFactory::Get();
2754 Property::Map propertyMap;
2755 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2757 // Create the visual.
2758 Visual::Base visual = factory.CreateVisual(propertyMap);
2760 DALI_TEST_CHECK(visual);
2762 Property::Map resultMap;
2763 visual.CreatePropertyMap(resultMap);
2765 // Check the property values from the returned map from visual
2766 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2767 DALI_TEST_CHECK(value);
2768 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2773 int UtcDaliVisualGetTransform(void)
2775 ToolkitTestApplication application;
2776 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2778 VisualFactory factory = VisualFactory::Get();
2779 Property::Map propertyMap;
2780 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2781 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2782 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2784 Dali::Property::Map visualMap;
2785 colorVisual.CreatePropertyMap(visualMap);
2786 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2787 Dali::Property::Map* map = value->GetMap();
2788 DALI_TEST_CHECK(map);
2790 //Test default values
2792 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2793 DALI_TEST_CHECK(typeValue);
2794 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2797 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2798 DALI_TEST_CHECK(typeValue);
2799 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2802 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2803 DALI_TEST_CHECK(typeValue);
2804 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2807 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2808 DALI_TEST_CHECK(typeValue);
2809 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2812 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2813 DALI_TEST_CHECK(typeValue);
2814 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2817 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2818 DALI_TEST_CHECK(typeValue);
2819 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2822 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2823 DALI_TEST_CHECK(typeValue);
2824 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2830 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2832 Property::Map transform;
2833 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2834 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2835 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2836 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2837 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2838 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2840 visual.SetTransformAndSize(transform, Vector2(100, 100));
2842 Dali::Property::Map visualMap;
2843 visual.CreatePropertyMap(visualMap);
2844 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2845 Dali::Property::Map* map = value->GetMap();
2846 DALI_TEST_CHECK(map);
2849 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2850 DALI_TEST_CHECK(typeValue);
2851 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2854 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2855 DALI_TEST_CHECK(typeValue);
2856 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2859 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2860 DALI_TEST_CHECK(typeValue);
2861 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2864 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2865 DALI_TEST_CHECK(typeValue);
2866 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2869 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2870 DALI_TEST_CHECK(typeValue);
2871 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2874 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2875 DALI_TEST_CHECK(typeValue);
2876 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2879 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2880 DALI_TEST_CHECK(typeValue);
2881 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2884 //Put the visual on the stage
2885 DummyControl actor = DummyControl::New(true);
2886 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2887 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2888 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2889 application.GetScene().Add(actor);
2891 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2892 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2894 application.SendNotification();
2895 application.Render(0);
2896 Renderer renderer(actor.GetRendererAt(0));
2898 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2899 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2901 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2902 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2904 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2905 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2907 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2908 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2910 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2911 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2913 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2914 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2916 //Set a new transform
2918 transform = DefaultTransform();
2919 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2920 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2921 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2922 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2923 visual.SetTransformAndSize(transform, Vector2(100, 100));
2924 application.SendNotification();
2925 application.Render(0);
2927 //Check that the values have changed in the renderer
2928 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2929 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2931 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2932 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2934 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2935 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2937 //Parent origin and anchor point should have the default values
2938 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2939 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2941 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2942 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2944 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2945 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2948 int UtcDaliVisualSetTransform01(void)
2950 ToolkitTestApplication application;
2951 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2953 VisualFactory factory = VisualFactory::Get();
2954 Property::Map propertyMap;
2955 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2956 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2957 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2958 Visual::Base visual = factory.CreateVisual(propertyMap);
2959 TestTransform(application, visual);
2960 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2965 int UtcDaliVisualSetTransform0(void)
2967 ToolkitTestApplication application;
2968 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2970 VisualFactory factory = VisualFactory::Get();
2971 Property::Map propertyMap;
2972 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2973 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2974 Visual::Base visual = factory.CreateVisual(propertyMap);
2975 TestTransform(application, visual);
2976 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2981 int UtcDaliVisualSetTransform1(void)
2983 ToolkitTestApplication application;
2984 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
2986 VisualFactory factory = VisualFactory::Get();
2987 Property::Map propertyMap;
2988 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
2989 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
2990 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
2991 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
2992 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
2993 Visual::Base visual = factory.CreateVisual(propertyMap);
2994 TestTransform(application, visual);
2995 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3000 int UtcDaliVisualSetTransform2(void)
3002 ToolkitTestApplication application;
3003 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3005 VisualFactory factory = VisualFactory::Get();
3006 Property::Map propertyMap;
3007 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3008 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3010 Property::Array stopOffsets;
3011 stopOffsets.PushBack(0.0f);
3012 stopOffsets.PushBack(0.3f);
3013 stopOffsets.PushBack(0.6f);
3014 stopOffsets.PushBack(0.8f);
3015 stopOffsets.PushBack(1.0f);
3016 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3018 Property::Array stopColors;
3019 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3020 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3021 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3022 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3023 stopColors.PushBack(Color::YELLOW);
3024 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3025 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3026 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3027 Visual::Base visual = factory.CreateVisual(propertyMap);
3028 TestTransform(application, visual);
3029 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3034 int UtcDaliVisualSetTransform3(void)
3036 ToolkitTestApplication application;
3037 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3039 VisualFactory factory = VisualFactory::Get();
3040 Property::Map propertyMap;
3041 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3042 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3043 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3044 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3045 Visual::Base visual = factory.CreateVisual(propertyMap);
3046 TestTransform(application, visual);
3047 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3052 int UtcDaliVisualSetTransform4(void)
3054 ToolkitTestApplication application;
3055 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3057 VisualFactory factory = VisualFactory::Get();
3058 Property::Map propertyMap;
3059 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3060 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3062 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3063 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3064 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3065 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3066 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3067 Visual::Base visual = factory.CreateVisual(propertyMap);
3068 TestTransform(application, visual);
3069 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3074 int UtcDaliVisualSetTransform5(void)
3076 ToolkitTestApplication application;
3077 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3079 VisualFactory factory = VisualFactory::Get();
3080 Property::Map propertyMap;
3081 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3082 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3083 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3084 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3085 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3086 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3087 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3088 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3089 Visual::Base visual = factory.CreateVisual(propertyMap);
3090 TestTransform(application, visual);
3091 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3096 int UtcDaliVisualSetTransform6(void)
3098 ToolkitTestApplication application;
3099 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3101 VisualFactory factory = VisualFactory::Get();
3102 Property::Map propertyMap;
3103 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3104 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3105 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3106 Visual::Base visual = factory.CreateVisual(propertyMap);
3107 TestTransform(application, visual);
3108 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3113 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3115 ToolkitTestApplication application;
3116 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3118 VisualFactory factory = VisualFactory::Get();
3119 Property::Map propertyMap;
3120 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3121 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3122 Visual::Base visual = factory.CreateVisual(propertyMap);
3124 Property::Map transform;
3125 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3126 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3127 visual.SetTransformAndSize(transform, Vector2(100, 100));
3129 Dali::Property::Map visualMap;
3130 visual.CreatePropertyMap(visualMap);
3131 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3132 Dali::Property::Map* map = value->GetMap();
3133 DALI_TEST_CHECK(map);
3136 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3137 DALI_TEST_CHECK(typeValue);
3138 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3141 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3142 DALI_TEST_CHECK(typeValue);
3143 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3149 int UtcDaliNPatchVisualCustomShader(void)
3151 ToolkitTestApplication application;
3152 tet_infoline("NPatchVisual with custom shader");
3154 VisualFactory factory = VisualFactory::Get();
3155 Property::Map properties;
3156 Property::Map shader;
3157 const std::string vertexShader = "Foobar";
3158 const std::string fragmentShader = "Foobar";
3159 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3160 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3162 Property::Map transformMap;
3163 transformMap["size"] = Vector2(0.5f, 0.5f);
3164 transformMap["offset"] = Vector2(20.0f, 0.0f);
3165 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3166 transformMap["anchorPoint"] = Align::CENTER;
3167 transformMap["origin"] = Align::CENTER;
3168 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3169 properties[Visual::Property::TRANSFORM] = transformMap;
3171 properties[Visual::Property::TYPE] = Visual::IMAGE;
3172 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3173 properties[Visual::Property::SHADER] = shader;
3174 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3175 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3177 Visual::Base visual = factory.CreateVisual(properties);
3178 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3180 // trigger creation through setting on stage
3181 DummyControl dummy = DummyControl::New(true);
3182 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3183 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3184 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3185 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3186 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3187 application.GetScene().Add(dummy);
3188 application.SendNotification();
3190 Renderer renderer = dummy.GetRendererAt(0);
3191 Shader shader2 = renderer.GetShader();
3192 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3193 Property::Map* map = value.GetMap();
3194 DALI_TEST_CHECK(map);
3196 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3197 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3199 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3200 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3202 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3203 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3205 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3206 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3211 int UtcDaliGradientVisualBlendMode(void)
3213 ToolkitTestApplication application;
3214 VisualFactory factory = VisualFactory::Get();
3216 Visual::Base opaqueGradientVisual = 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(Color::GREEN)));
3219 Visual::Base alphaGradientVisual = factory.CreateVisual(
3220 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))));
3222 DummyControl control = DummyControl::New(true);
3223 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3224 application.GetScene().Add(control);
3226 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3227 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3228 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3230 application.SendNotification();
3231 application.Render();
3233 // 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
3234 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3235 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3236 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3241 int UtcDaliVisualRendererRemovalAndReAddition(void)
3243 ToolkitTestApplication application;
3244 tet_infoline("UtcDaliVisualRendererRemoval");
3246 VisualFactory factory = VisualFactory::Get();
3247 Property::Map propertyMap;
3248 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3249 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3250 Visual::Base visual = factory.CreateVisual(propertyMap);
3252 visual.SetDepthIndex(1);
3254 DummyControl dummyControl = DummyControl::New(true);
3255 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3256 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3257 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3259 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3260 tet_infoline("Add control with visual to stage and check renderer count is 1");
3262 application.GetScene().Add(dummyControl);
3264 application.SendNotification();
3265 application.Render();
3267 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3269 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3270 application.GetScene().Remove(dummyControl);
3271 application.SendNotification();
3272 application.Render();
3274 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3276 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3278 application.GetScene().Add(dummyControl);
3280 application.SendNotification();
3281 application.Render();
3283 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3288 int UtcDaliVisualTextVisualRender(void)
3290 ToolkitTestApplication application;
3291 tet_infoline("UtcDaliVisualTextVisualRender");
3293 VisualFactory factory = VisualFactory::Get();
3294 Property::Map propertyMap;
3295 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3296 propertyMap.Insert("mixColor", Color::WHITE);
3297 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3298 propertyMap.Insert("enableMarkup", false);
3299 propertyMap.Insert("text", "Hello world");
3300 propertyMap.Insert("fontFamily", "TizenSans");
3302 Property::Map fontStyleMapSet;
3303 fontStyleMapSet.Insert("weight", "bold");
3304 propertyMap.Insert("fontStyle", fontStyleMapSet);
3306 propertyMap.Insert("pointSize", 12.f);
3307 propertyMap.Insert("multiLine", true);
3308 propertyMap.Insert("horizontalAlignment", "CENTER");
3309 propertyMap.Insert("verticalAlignment", "CENTER");
3310 propertyMap.Insert("textColor", Color::RED);
3311 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3312 textVisual.SetDepthIndex(1);
3314 DummyControl dummyControl = DummyControl::New(true);
3315 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3316 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3317 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3319 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3320 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3322 application.GetScene().Add(dummyControl);
3323 application.SendNotification();
3324 application.Render();
3326 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3327 propertyMap.Clear();
3328 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3329 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3330 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3331 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3333 Property::Map transformMap;
3334 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3335 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3337 textVisual = factory.CreateVisual(propertyMap);
3338 textVisual.SetDepthIndex(1);
3340 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3341 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3343 application.SendNotification(); // force process events to ensure text visual
3344 // adds renderer to the dummy control in OnRelayout
3345 application.Render();
3347 Renderer renderer = dummyControl.GetRendererAt(0u);
3348 Property::Index index = renderer.GetPropertyIndex("transformSize");
3350 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3351 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3356 int UtcDaliVisualTextVisualDisableEnable(void)
3358 ToolkitTestApplication application;
3359 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3361 VisualFactory factory = VisualFactory::Get();
3362 Property::Map propertyMap;
3363 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3364 propertyMap.Insert("mixColor", Color::WHITE);
3365 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3366 propertyMap.Insert("enableMarkup", false);
3367 propertyMap.Insert("text", "Hello world");
3368 propertyMap.Insert("fontFamily", "TizenSans");
3370 Property::Map fontStyleMapSet;
3371 fontStyleMapSet.Insert("weight", "bold");
3372 propertyMap.Insert("fontStyle", fontStyleMapSet);
3374 propertyMap.Insert("pointSize", 12.f);
3375 propertyMap.Insert("multiLine", true);
3376 propertyMap.Insert("horizontalAlignment", "CENTER");
3377 propertyMap.Insert("verticalAlignment", "CENTER");
3378 propertyMap.Insert("textColor", Color::RED);
3379 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3380 textVisual.SetDepthIndex(1);
3382 DummyControl dummyControl = DummyControl::New(true);
3383 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3384 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3385 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3387 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3388 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3390 application.GetScene().Add(dummyControl);
3391 application.SendNotification();
3392 application.Render();
3394 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3396 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3398 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3400 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3402 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3407 int UtcDaliVisualPremultipliedAlpha(void)
3409 ToolkitTestApplication application;
3410 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3412 VisualFactory factory = VisualFactory::Get();
3414 // image visual, test default value ( true )
3416 Visual::Base imageVisual = factory.CreateVisual(
3418 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3419 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3421 Dali::Property::Map visualMap;
3422 imageVisual.CreatePropertyMap(visualMap);
3423 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3426 DALI_TEST_CHECK(value);
3427 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3430 // image visual, override premultiplied
3432 Visual::Base imageVisual = factory.CreateVisual(
3434 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3435 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3436 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3438 Dali::Property::Map visualMap;
3439 imageVisual.CreatePropertyMap(visualMap);
3440 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3443 DALI_TEST_CHECK(value);
3444 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3447 // svg visual ( premultiplied alpha by default is true, and cannot change value )
3449 Visual::Base imageVisual = factory.CreateVisual(
3451 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3452 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3454 Dali::Property::Map visualMap;
3455 imageVisual.CreatePropertyMap(visualMap);
3456 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3459 DALI_TEST_CHECK(value);
3460 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3463 Visual::Base imageVisual = factory.CreateVisual(
3465 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3466 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3467 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3469 Dali::Property::Map visualMap;
3470 imageVisual.CreatePropertyMap(visualMap);
3471 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3474 DALI_TEST_CHECK(value);
3475 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3478 // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3480 Visual::Base imageVisual = factory.CreateVisual(
3482 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3483 .Add(ImageVisual::Property::URL, "something.json"));
3485 Dali::Property::Map visualMap;
3486 imageVisual.CreatePropertyMap(visualMap);
3487 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3490 DALI_TEST_CHECK(value);
3491 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3494 Visual::Base imageVisual = factory.CreateVisual(
3496 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3497 .Add(ImageVisual::Property::URL, "something.json")
3498 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3500 Dali::Property::Map visualMap;
3501 imageVisual.CreatePropertyMap(visualMap);
3502 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3505 DALI_TEST_CHECK(value);
3506 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3509 // text visual ( premultiplied alpha by default is true, and cannot change value )
3511 Visual::Base textVisual = factory.CreateVisual(
3513 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3514 .Add(TextVisual::Property::TEXT, "Text"));
3516 Dali::Property::Map visualMap;
3517 textVisual.CreatePropertyMap(visualMap);
3518 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3521 DALI_TEST_CHECK(value);
3522 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3525 Visual::Base textVisual = factory.CreateVisual(
3527 .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3528 .Add(TextVisual::Property::TEXT, "Text")
3529 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3531 Dali::Property::Map visualMap;
3532 textVisual.CreatePropertyMap(visualMap);
3533 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3536 DALI_TEST_CHECK(value);
3537 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3540 // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3542 Visual::Base gradientVisual = factory.CreateVisual(
3544 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3545 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3546 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3547 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3549 Dali::Property::Map visualMap;
3550 gradientVisual.CreatePropertyMap(visualMap);
3551 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3554 DALI_TEST_CHECK(value);
3555 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3558 Visual::Base gradientVisual = factory.CreateVisual(
3560 .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3561 .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3562 .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3563 .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3564 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3566 Dali::Property::Map visualMap;
3567 gradientVisual.CreatePropertyMap(visualMap);
3568 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3571 DALI_TEST_CHECK(value);
3572 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3575 // color visual ( premultiplied alpha by default is false, and cannot change value )
3577 Visual::Base colorVisual = factory.CreateVisual(
3579 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3580 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3582 Dali::Property::Map visualMap;
3583 colorVisual.CreatePropertyMap(visualMap);
3584 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3587 DALI_TEST_CHECK(value);
3588 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3591 Visual::Base colorVisual = factory.CreateVisual(
3593 .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3594 .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3595 .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3597 Dali::Property::Map visualMap;
3598 colorVisual.CreatePropertyMap(visualMap);
3599 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3602 DALI_TEST_CHECK(value);
3603 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3609 int UtcDaliRegisterVisualOrder(void)
3611 ToolkitTestApplication application;
3612 tet_infoline("Register Visual Order");
3614 DummyControl dummyControl = DummyControl::New(true);
3615 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3617 VisualFactory factory = VisualFactory::Get();
3618 Property::Map propertyMap;
3619 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3620 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3622 tet_infoline("Register visual, should have depth index of 0.0f");
3623 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3624 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3625 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3627 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3629 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3630 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3631 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3633 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3634 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3635 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3637 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3638 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3639 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3641 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3642 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3643 labelVisual.SetDepthIndex(-2000);
3644 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3645 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3647 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3648 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3649 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3650 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3651 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3652 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3654 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3655 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3656 anotherTestVisual2Replacement.SetDepthIndex(2000);
3657 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3658 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3660 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3661 application.GetScene().Add(dummyControl);
3666 int UtcDaliRegisterVisualOrder02(void)
3668 ToolkitTestApplication application;
3669 tet_infoline("Register Visual Order with Background Set");
3671 DummyControl dummyControl = DummyControl::New(true);
3672 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3674 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3676 VisualFactory factory = VisualFactory::Get();
3677 Property::Map propertyMap;
3678 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3679 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3681 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3683 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3685 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3686 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3687 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3688 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3689 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3691 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3692 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3693 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3694 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3696 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3697 application.GetScene().Add(dummyControl);
3702 int UtcDaliRegisterVisualWithDepthIndex(void)
3704 ToolkitTestApplication application;
3705 tet_infoline("Register a Visual With Depth Index");
3707 DummyControl dummyControl = DummyControl::New(true);
3708 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3710 VisualFactory factory = VisualFactory::Get();
3711 Property::Map propertyMap;
3712 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3713 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3715 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3716 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3717 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3718 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3719 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3721 tet_infoline("Register another visual with a depth index and it disabled");
3722 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3723 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3724 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3725 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3727 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3728 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3729 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3730 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3731 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3733 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3734 application.GetScene().Add(dummyControl);
3739 int UtcDaliSvgVisualCustomShader(void)
3741 ToolkitTestApplication application;
3742 tet_infoline("SvgVisual with custom shader");
3744 VisualFactory factory = VisualFactory::Get();
3745 Property::Map properties;
3746 Property::Map shader;
3747 const std::string vertexShader = "Foobar";
3748 const std::string fragmentShader = "Foobar";
3749 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3750 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3752 properties[Visual::Property::TYPE] = Visual::IMAGE;
3753 properties[Visual::Property::SHADER] = shader;
3754 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3756 Visual::Base visual = factory.CreateVisual(properties);
3758 // trigger creation through setting on stage
3759 DummyControl dummy = DummyControl::New(true);
3760 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3761 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3763 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3764 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3765 application.GetScene().Add(dummy);
3767 application.SendNotification();
3768 application.Render();
3770 // Wait for loading & rasterization
3771 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3773 Renderer renderer = dummy.GetRendererAt(0);
3774 Shader shader2 = renderer.GetShader();
3775 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3776 Property::Map* map = value.GetMap();
3777 DALI_TEST_CHECK(map);
3779 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3780 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3782 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3783 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3788 int UtcDaliVisualRoundedCorner(void)
3790 tet_infoline("UtcDaliVisualRoundedCorner");
3792 static std::vector<UniformData> customUniforms =
3794 UniformData("cornerRadius", Property::Type::VECTOR4),
3795 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3800 ToolkitTestApplication application;
3801 TestGraphicsController& graphics = application.GetGraphicsController();
3802 graphics.AddCustomUniforms(customUniforms);
3804 VisualFactory factory = VisualFactory::Get();
3805 Property::Map properties;
3806 float cornerRadius = 30.0f;
3808 properties[Visual::Property::TYPE] = Visual::IMAGE;
3809 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3810 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3812 Visual::Base visual = factory.CreateVisual(properties);
3814 // trigger creation through setting on stage
3815 DummyControl dummy = DummyControl::New(true);
3816 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3817 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3819 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3820 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3821 application.GetScene().Add(dummy);
3823 application.SendNotification();
3824 application.Render();
3826 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3828 application.SendNotification();
3829 application.Render();
3831 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3832 // Default corner radius policy is absolute.
3833 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3838 ToolkitTestApplication application;
3839 TestGraphicsController& graphics = application.GetGraphicsController();
3840 graphics.AddCustomUniforms(customUniforms);
3842 VisualFactory factory = VisualFactory::Get();
3843 Property::Map properties;
3844 float cornerRadius = 30.0f;
3846 properties[Visual::Property::TYPE] = Visual::COLOR;
3847 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3848 properties["cornerRadius"] = cornerRadius;
3849 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3851 Visual::Base visual = factory.CreateVisual(properties);
3853 // trigger creation through setting on stage
3854 DummyControl dummy = DummyControl::New(true);
3855 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3856 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3858 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3859 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3860 application.GetScene().Add(dummy);
3862 application.SendNotification();
3863 application.Render();
3865 application.SendNotification();
3866 application.Render();
3868 // Currently test with multiple program doesn't work well. will fix another day
3869 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3870 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3875 ToolkitTestApplication application;
3876 TestGraphicsController& graphics = application.GetGraphicsController();
3877 graphics.AddCustomUniforms(customUniforms);
3879 VisualFactory factory = VisualFactory::Get();
3880 Property::Map properties;
3881 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3883 properties[Visual::Property::TYPE] = Visual::COLOR;
3884 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3885 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3886 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3888 Visual::Base visual = factory.CreateVisual(properties);
3890 // trigger creation through setting on stage
3891 DummyControl dummy = DummyControl::New(true);
3892 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3893 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3895 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3896 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3897 application.GetScene().Add(dummy);
3899 application.SendNotification();
3900 application.Render();
3902 application.SendNotification();
3903 application.Render();
3905 // Currently test with multiple program doesn't work well. will fix another day
3906 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3907 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3910 // color visual 3 - invalid value
3912 ToolkitTestApplication application;
3913 TestGraphicsController& graphics = application.GetGraphicsController();
3914 graphics.AddCustomUniforms(customUniforms);
3916 VisualFactory factory = VisualFactory::Get();
3917 Property::Map properties;
3918 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3920 properties[Visual::Property::TYPE] = Visual::COLOR;
3921 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3922 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3923 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3925 Visual::Base visual = factory.CreateVisual(properties);
3927 // trigger creation through setting on stage
3928 DummyControl dummy = DummyControl::New(true);
3929 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3930 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3932 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3933 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3934 application.GetScene().Add(dummy);
3936 application.SendNotification();
3937 application.Render();
3939 application.SendNotification();
3940 application.Render();
3942 // Currently test with multiple program doesn't work well. will fix another day
3943 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3944 // Default corner radius policy is absolute.
3945 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3950 ToolkitTestApplication application;
3951 TestGraphicsController& graphics = application.GetGraphicsController();
3952 graphics.AddCustomUniforms(customUniforms);
3954 VisualFactory factory = VisualFactory::Get();
3955 Property::Map properties;
3956 float cornerRadius = 30.0f;
3958 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3959 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3960 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3961 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3962 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3963 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3965 Property::Array stopOffsets;
3966 stopOffsets.PushBack(0.0f);
3967 stopOffsets.PushBack(0.6f);
3968 stopOffsets.PushBack(1.0f);
3969 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3971 Property::Array stopColors;
3972 stopColors.PushBack(Color::RED);
3973 stopColors.PushBack(Color::YELLOW);
3974 stopColors.PushBack(Color::GREEN);
3975 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3977 Visual::Base visual = factory.CreateVisual(properties);
3979 // trigger creation through setting on stage
3980 DummyControl dummy = DummyControl::New(true);
3981 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3982 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3984 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3985 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3986 application.GetScene().Add(dummy);
3988 application.SendNotification();
3989 application.Render();
3991 application.SendNotification();
3992 application.Render();
3994 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3995 // Default corner radius policy is absolute.
3996 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3999 // animated image visual
4001 ToolkitTestApplication application;
4002 TestGraphicsController& graphics = application.GetGraphicsController();
4003 graphics.AddCustomUniforms(customUniforms);
4005 VisualFactory factory = VisualFactory::Get();
4006 Property::Map properties;
4007 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4009 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4010 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4011 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4012 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4013 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4015 Visual::Base visual = factory.CreateVisual(properties);
4017 // trigger creation through setting on stage
4018 DummyControl dummy = DummyControl::New(true);
4019 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4020 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4022 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4023 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4024 application.GetScene().Add(dummy);
4026 application.SendNotification();
4027 application.Render();
4029 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4031 application.SendNotification();
4032 application.Render();
4034 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4035 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4038 // vector image visual
4040 ToolkitTestApplication application;
4041 TestGraphicsController& graphics = application.GetGraphicsController();
4042 graphics.AddCustomUniforms(customUniforms);
4044 VisualFactory factory = VisualFactory::Get();
4045 Property::Map properties;
4046 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4048 properties[Visual::Property::TYPE] = Visual::SVG;
4049 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4050 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4052 Visual::Base visual = factory.CreateVisual(properties);
4054 // trigger creation through setting on stage
4055 DummyControl dummy = DummyControl::New(true);
4056 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4057 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4059 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4060 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4061 application.GetScene().Add(dummy);
4063 application.SendNotification();
4064 application.Render();
4066 // Wait for loading & rasterization
4067 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4069 application.SendNotification();
4070 application.Render();
4072 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4073 // Default corner radius policy is absolute.
4074 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4077 // animated vector image visual
4079 ToolkitTestApplication application;
4080 TestGraphicsController& graphics = application.GetGraphicsController();
4081 graphics.AddCustomUniforms(customUniforms);
4083 VisualFactory factory = VisualFactory::Get();
4084 Property::Map properties;
4085 float cornerRadius = 1.3f;
4087 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4088 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4089 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4090 properties["cornerRadius"] = cornerRadius;
4091 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4093 Visual::Base visual = factory.CreateVisual(properties);
4095 // trigger creation through setting on stage
4096 DummyControl dummy = DummyControl::New(true);
4097 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4098 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4100 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4101 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4102 application.GetScene().Add(dummy);
4104 application.SendNotification();
4105 application.Render();
4107 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4109 application.SendNotification();
4110 application.Render();
4112 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4113 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4119 int UtcDaliVisualBorderline(void)
4121 tet_infoline("UtcDaliVisualBorderline");
4123 static std::vector<UniformData> customUniforms =
4125 UniformData("cornerRadius", Property::Type::VECTOR4),
4126 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4127 UniformData("borderlineWidth", Property::Type::FLOAT),
4128 UniformData("borderlineColor", Property::Type::VECTOR4),
4129 UniformData("borderlineOffset", Property::Type::FLOAT),
4134 ToolkitTestApplication application;
4135 TestGraphicsController& graphics = application.GetGraphicsController();
4136 graphics.AddCustomUniforms(customUniforms);
4138 VisualFactory factory = VisualFactory::Get();
4139 Property::Map properties;
4140 float cornerRadius = 5.0f;
4141 float borderlineWidth = 30.0f;
4142 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4143 float borderlineOffset = 1.0f;
4145 properties[Visual::Property::TYPE] = Visual::IMAGE;
4146 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4147 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4148 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4149 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4150 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4152 Visual::Base visual = factory.CreateVisual(properties);
4154 // trigger creation through setting on stage
4155 DummyControl dummy = DummyControl::New(true);
4156 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4157 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4159 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4160 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4161 application.GetScene().Add(dummy);
4163 application.SendNotification();
4164 application.Render();
4166 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4168 application.SendNotification();
4169 application.Render();
4171 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4172 // Default corner radius policy is absolute.
4173 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4174 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4175 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4176 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4181 ToolkitTestApplication application;
4182 TestGraphicsController& graphics = application.GetGraphicsController();
4183 graphics.AddCustomUniforms(customUniforms);
4185 VisualFactory factory = VisualFactory::Get();
4186 Property::Map properties;
4187 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4188 float borderlineWidth = 30.0f;
4189 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4190 float borderlineOffset = -0.4f;
4192 properties[Visual::Property::TYPE] = Visual::COLOR;
4193 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4194 properties["cornerRadius"] = cornerRadius;
4195 properties["borderlineWidth"] = borderlineWidth;
4196 properties["borderlineColor"] = borderlineColor;
4197 properties["borderlineOffset"] = borderlineOffset;
4199 Visual::Base visual = factory.CreateVisual(properties);
4201 // trigger creation through setting on stage
4202 DummyControl dummy = DummyControl::New(true);
4203 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4204 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4206 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4207 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4208 application.GetScene().Add(dummy);
4210 application.SendNotification();
4211 application.Render();
4213 application.SendNotification();
4214 application.Render();
4216 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4217 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4218 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4219 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4222 // color visual 2, default color, default offset
4224 ToolkitTestApplication application;
4225 TestGraphicsController& graphics = application.GetGraphicsController();
4226 graphics.AddCustomUniforms(customUniforms);
4228 VisualFactory factory = VisualFactory::Get();
4229 Property::Map properties;
4230 float borderlineWidth = 30.0f;
4232 properties[Visual::Property::TYPE] = Visual::COLOR;
4233 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4234 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4236 Visual::Base visual = factory.CreateVisual(properties);
4238 // trigger creation through setting on stage
4239 DummyControl dummy = DummyControl::New(true);
4240 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4241 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4243 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4244 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4245 application.GetScene().Add(dummy);
4247 application.SendNotification();
4248 application.Render();
4250 application.SendNotification();
4251 application.Render();
4253 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4254 // Default borderline color is BLACK.
4255 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4256 // Default borderline offset is 0.0f.
4257 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4260 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4262 ToolkitTestApplication application;
4263 TestGraphicsController& graphics = application.GetGraphicsController();
4264 graphics.AddCustomUniforms(customUniforms);
4266 VisualFactory factory = VisualFactory::Get();
4267 Property::Map properties;
4268 float borderlineWidth = 30.0f;
4269 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4270 float borderlineOffset = 37.4f;
4272 properties[Visual::Property::TYPE] = Visual::COLOR;
4273 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4274 properties["borderlineWidth"] = borderlineWidth;
4275 properties["borderlineColor"] = borderlineColor;
4276 properties["borderlineOffset"] = borderlineOffset;
4278 Visual::Base visual = factory.CreateVisual(properties);
4280 // trigger creation through setting on stage
4281 DummyControl dummy = DummyControl::New(true);
4282 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4283 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4285 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4286 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4287 application.GetScene().Add(dummy);
4289 application.SendNotification();
4290 application.Render();
4292 application.SendNotification();
4293 application.Render();
4295 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4296 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4297 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4298 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4303 ToolkitTestApplication application;
4304 TestGraphicsController& graphics = application.GetGraphicsController();
4305 graphics.AddCustomUniforms(customUniforms);
4307 VisualFactory factory = VisualFactory::Get();
4308 Property::Map properties;
4309 float borderlineWidth = 30.0f;
4310 float cornerRadius = 70.0f;
4312 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4313 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4314 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4315 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4316 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4317 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4318 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4320 Property::Array stopOffsets;
4321 stopOffsets.PushBack(0.0f);
4322 stopOffsets.PushBack(0.6f);
4323 stopOffsets.PushBack(1.0f);
4324 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4326 Property::Array stopColors;
4327 stopColors.PushBack(Color::RED);
4328 stopColors.PushBack(Color::YELLOW);
4329 stopColors.PushBack(Color::GREEN);
4330 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4332 Visual::Base visual = factory.CreateVisual(properties);
4334 // trigger creation through setting on stage
4335 DummyControl dummy = DummyControl::New(true);
4336 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4337 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4339 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4340 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4341 application.GetScene().Add(dummy);
4343 application.SendNotification();
4344 application.Render();
4346 application.SendNotification();
4347 application.Render();
4349 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4350 // Default corner radius policy is absolute.
4351 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4352 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4353 // Default borderline color is BLACK.
4354 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4355 // Default borderline offset is 0.0f.
4356 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4359 // animated image visual
4361 ToolkitTestApplication application;
4362 TestGraphicsController& graphics = application.GetGraphicsController();
4363 graphics.AddCustomUniforms(customUniforms);
4365 VisualFactory factory = VisualFactory::Get();
4366 Property::Map properties;
4367 float borderlineWidth = 24.0f;
4368 float borderlineOffset = -1.0f;
4370 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4371 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4372 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4373 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4374 properties["borderlineOffset"] = borderlineOffset;
4376 Visual::Base visual = factory.CreateVisual(properties);
4378 // trigger creation through setting on stage
4379 DummyControl dummy = DummyControl::New(true);
4380 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4381 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4383 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4384 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4385 application.GetScene().Add(dummy);
4387 application.SendNotification();
4388 application.Render();
4390 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4392 application.SendNotification();
4393 application.Render();
4395 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4396 // Default borderline color is BLACK.
4397 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4398 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4401 // vector image visual
4403 ToolkitTestApplication application;
4404 TestGraphicsController& graphics = application.GetGraphicsController();
4405 graphics.AddCustomUniforms(customUniforms);
4407 VisualFactory factory = VisualFactory::Get();
4408 Property::Map properties;
4409 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4410 float borderlineWidth = 27.0f;
4411 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4413 properties[Visual::Property::TYPE] = Visual::SVG;
4414 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4415 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4416 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4417 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4419 Visual::Base visual = factory.CreateVisual(properties);
4421 // trigger creation through setting on stage
4422 DummyControl dummy = DummyControl::New(true);
4423 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4424 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4426 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4427 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4428 application.GetScene().Add(dummy);
4430 application.SendNotification();
4431 application.Render();
4433 // Wait for loading & rasterization
4434 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4436 application.SendNotification();
4437 application.Render();
4439 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4440 // Default corner radius policy is absolute.
4441 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4442 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4443 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4444 // Default borderline offset is 0.0.
4445 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4448 // animated vector image visual
4450 ToolkitTestApplication application;
4451 TestGraphicsController& graphics = application.GetGraphicsController();
4452 graphics.AddCustomUniforms(customUniforms);
4454 VisualFactory factory = VisualFactory::Get();
4455 Property::Map properties;
4456 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4457 float borderlineWidth = 13.0f;
4458 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4459 float borderlineOffset = 13.0f;
4461 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4462 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4463 properties["cornerRadius"] = cornerRadius;
4464 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4465 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4466 properties["borderlineColor"] = borderlineColor;
4467 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4469 Visual::Base visual = factory.CreateVisual(properties);
4471 // trigger creation through setting on stage
4472 DummyControl dummy = DummyControl::New(true);
4473 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4474 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4476 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4477 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4478 application.GetScene().Add(dummy);
4480 application.SendNotification();
4481 application.Render();
4483 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4485 application.SendNotification();
4486 application.Render();
4488 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4489 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4490 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4491 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4492 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4498 int UtcDaliVisualBorderlineBlendModeTest(void)
4500 ToolkitTestApplication application;
4501 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4502 VisualFactory factory = VisualFactory::Get();
4504 // Case 1 : Test which doesn't support borderline feature.
4506 tet_printf("Test Unsupported visual type\n");
4507 Property::Map propertyMap;
4508 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4509 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4510 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4511 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4513 DummyControl actor = DummyControl::New(true);
4514 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4515 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4516 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4517 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4518 application.GetScene().Add(actor);
4520 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4522 Renderer renderer = actor.GetRendererAt(0);
4524 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4525 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4526 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4528 application.GetScene().Remove(actor);
4531 // Case 2 : Test which support borderline feature.
4533 tet_printf("Test normal case\n");
4534 Property::Map propertyMap;
4535 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4536 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4537 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4538 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4540 DummyControl actor = DummyControl::New(true);
4541 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4542 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4543 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4544 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4545 application.GetScene().Add(actor);
4547 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4549 Renderer renderer = actor.GetRendererAt(0);
4551 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4552 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4553 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4555 application.GetScene().Remove(actor);
4558 // Case 3 : Test which animated borderline.
4560 tet_printf("Test borderline animate case\n");
4561 Property::Map propertyMap;
4562 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4563 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4564 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4566 DummyControl actor = DummyControl::New(true);
4567 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4568 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4569 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4570 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4571 application.GetScene().Add(actor);
4573 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4575 Renderer renderer = actor.GetRendererAt(0);
4577 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4578 // BlendMode is AUTO.
4579 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4581 Animation animation = Animation::New(0.1f);
4582 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4585 application.SendNotification();
4586 application.Render();
4587 application.Render(101u); // End of animation
4589 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4590 // BlendMode is ON_WITHOUT_CULL.
4591 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4593 Animation revanimation = Animation::New(0.1f);
4594 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4595 revanimation.Play();
4597 application.SendNotification();
4598 application.Render();
4599 application.Render(101u); // End of animation
4601 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4602 // BlendMode is still ON_WITHOUT_CULL.
4603 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4605 application.GetScene().Remove(actor);
4608 // Case 4 : Test which animated corner radius occur.
4610 tet_printf("Test borderline animate case\n");
4611 Property::Map propertyMap;
4612 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4613 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4614 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4615 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4617 DummyControl actor = DummyControl::New(true);
4618 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4619 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4620 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4621 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4622 application.GetScene().Add(actor);
4624 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4626 Renderer renderer = actor.GetRendererAt(0);
4628 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4629 // BlendMode is ON_WITHOUT_CULL.
4630 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4632 Animation animation = Animation::New(0.1f);
4633 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4636 application.SendNotification();
4637 application.Render();
4638 application.Render(101u); // End of animation
4640 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4641 // BlendMode is ON_WITHOUT_CULL.
4642 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4644 application.GetScene().Remove(actor);
4650 int UtcDaliVisualBorderlineColorAnimateTest(void)
4652 ToolkitTestApplication application;
4653 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4655 TestGraphicsController& graphics = application.GetGraphicsController();
4656 static std::vector<UniformData> customUniforms =
4658 UniformData("mixColor", Property::Type::VECTOR3),
4659 UniformData("cornerRadius", Property::Type::VECTOR4),
4660 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4661 UniformData("borderlineWidth", Property::Type::FLOAT),
4662 UniformData("borderlineColor", Property::Type::VECTOR4),
4663 UniformData("borderlineOffset", Property::Type::FLOAT),
4665 graphics.AddCustomUniforms(customUniforms);
4668 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4669 const float INITIAL_MIX_OPACITY(0.5f);
4670 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4671 const float INITIAL_ACTOR_OPACITY(1.0f);
4672 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4673 const float TARGET_MIX_OPACITY(0.8f);
4674 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4675 const float TARGET_ACTOR_OPACITY(0.5f);
4677 VisualFactory factory = VisualFactory::Get();
4678 Property::Map propertyMap;
4679 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4680 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4681 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4682 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4683 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4684 Visual::Base visual = factory.CreateVisual(propertyMap);
4686 DummyControl actor = DummyControl::New(true);
4687 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4688 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4689 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4690 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4691 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4692 application.GetScene().Add(actor);
4694 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4696 Animation animation = Animation::New(4.0f);
4697 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4698 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4699 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4700 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4703 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4705 application.SendNotification();
4706 application.Render(0);
4707 application.Render(2000u); // halfway point
4708 application.SendNotification();
4710 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4711 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4712 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4713 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4714 halfwayMixOpacity *= halfwayActorOpacity;
4715 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4716 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4717 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4718 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4720 application.Render(2001u); // go past end
4721 application.SendNotification(); // Trigger signals
4723 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4724 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4725 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4726 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4727 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4735 int UtcDaliColorVisualBlurRadius(void)
4737 ToolkitTestApplication application;
4738 tet_infoline("UtcDaliColorVisualBlurRadius");
4740 static std::vector<UniformData> customUniforms =
4742 UniformData("blurRadius", Property::Type::FLOAT),
4745 TestGraphicsController& graphics = application.GetGraphicsController();
4746 graphics.AddCustomUniforms(customUniforms);
4748 VisualFactory factory = VisualFactory::Get();
4749 Property::Map properties;
4750 float blurRadius = 20.0f;
4752 properties[Visual::Property::TYPE] = Visual::COLOR;
4753 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4754 properties["blurRadius"] = blurRadius;
4756 Visual::Base visual = factory.CreateVisual(properties);
4758 // trigger creation through setting on stage
4759 DummyControl dummy = DummyControl::New(true);
4760 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4761 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4763 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4764 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4765 application.GetScene().Add(dummy);
4767 application.SendNotification();
4768 application.Render();
4770 application.SendNotification();
4771 application.Render();
4773 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4778 int UtcDaliVisualGetType(void)
4780 ToolkitTestApplication application;
4781 tet_infoline("UtcDaliVisualGetType");
4783 VisualFactory factory = VisualFactory::Get();
4786 Property::Map properties;
4787 properties[Visual::Property::TYPE] = Visual::BORDER;
4788 Visual::Base visual = factory.CreateVisual(properties);
4790 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4794 Property::Map properties;
4795 properties[Visual::Property::TYPE] = Visual::COLOR;
4796 Visual::Base visual = factory.CreateVisual(properties);
4798 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4802 Property::Map properties;
4803 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4804 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4805 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4806 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4807 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4808 Property::Array stopColors;
4809 stopColors.PushBack(Color::RED);
4810 stopColors.PushBack(Color::GREEN);
4811 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4812 Visual::Base visual = factory.CreateVisual(properties);
4814 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4818 Property::Map properties;
4819 properties[Visual::Property::TYPE] = Visual::IMAGE;
4820 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4821 Visual::Base visual = factory.CreateVisual(properties);
4823 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4827 Property::Map properties;
4828 properties[Visual::Property::TYPE] = Visual::MESH;
4829 Visual::Base visual = factory.CreateVisual(properties);
4831 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4835 Property::Map properties;
4836 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4837 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4838 Visual::Base visual = factory.CreateVisual(properties);
4840 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4844 Property::Map properties;
4845 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4846 Visual::Base visual = factory.CreateVisual(properties);
4848 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4852 Property::Map properties;
4853 properties[Visual::Property::TYPE] = Visual::TEXT;
4854 Visual::Base visual = factory.CreateVisual(properties);
4856 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4860 Property::Map properties;
4861 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4862 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4863 Visual::Base visual = factory.CreateVisual(properties);
4865 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4869 Property::Map properties;
4870 properties[Visual::Property::TYPE] = Visual::SVG;
4871 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4872 Visual::Base visual = factory.CreateVisual(properties);
4874 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4878 Property::Map properties;
4879 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4880 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4881 Visual::Base visual = factory.CreateVisual(properties);
4883 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4887 Property::Map properties;
4888 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4889 Visual::Base visual = factory.CreateVisual(properties);
4891 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4895 Property::Map properties;
4896 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4897 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4898 Visual::Base visual = factory.CreateVisual(properties);
4900 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4904 Property::Map properties;
4905 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4906 Visual::Base visual = factory.CreateVisual(properties);
4908 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4914 int UtcDaliVisualGetVisualProperty01(void)
4916 ToolkitTestApplication application;
4917 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4919 static std::vector<UniformData> customUniforms =
4921 UniformData("mixColor", Property::Type::VECTOR3),
4922 UniformData("offset", Property::Type::VECTOR2),
4923 UniformData("size", Property::Type::VECTOR2),
4924 UniformData("cornerRadius", Property::Type::VECTOR4),
4925 UniformData("blurRadius", Property::Type::FLOAT),
4926 UniformData("borderlineWidth", Property::Type::FLOAT),
4927 UniformData("borderlineColor", Property::Type::VECTOR4),
4928 UniformData("borderlineOffset", Property::Type::FLOAT)};
4930 TestGraphicsController& graphics = application.GetGraphicsController();
4931 graphics.AddCustomUniforms(customUniforms);
4933 VisualFactory factory = VisualFactory::Get();
4934 Property::Map propertyMap;
4935 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4936 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4937 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4938 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4939 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4940 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4941 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4942 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4943 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4945 DummyControl dummyControl = DummyControl::New(true);
4946 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4947 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4948 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4949 application.GetScene().Add(dummyControl);
4951 application.SendNotification();
4952 application.Render();
4954 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4955 Vector2 targetOffset(0.05f, 0.05f);
4956 Vector2 targetSize(1.1f, 1.1f);
4957 float targetOpacity = 0.5f;
4958 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4959 float targetBlurRadius = 10.0f;
4960 float targetBorderlineWidth = 25.0f;
4961 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4962 float targetBorderlineOffset = -1.0f;
4964 Animation animation = Animation::New(1.0f);
4965 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4966 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4967 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4968 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4969 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4970 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4971 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4972 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4973 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4976 application.SendNotification();
4977 application.Render();
4978 application.Render(1001u); // End of animation
4980 Property::Map resultMap;
4981 colorVisual.CreatePropertyMap(resultMap);
4983 // Test property values: they should be updated
4984 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4985 DALI_TEST_CHECK(colorValue);
4986 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4988 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4989 Dali::Property::Map* transformMap = transformValue->GetMap();
4990 DALI_TEST_CHECK(transformMap);
4992 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4993 DALI_TEST_CHECK(offsetValue);
4994 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4996 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4997 DALI_TEST_CHECK(sizeValue);
4998 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5000 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5001 DALI_TEST_CHECK(cornerRadiusValue);
5002 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5004 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5005 DALI_TEST_CHECK(blurRadiusValue);
5006 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5008 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5009 DALI_TEST_CHECK(borderlineWidthValue);
5010 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5012 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5013 DALI_TEST_CHECK(borderlineColorValue);
5014 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5016 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5017 DALI_TEST_CHECK(borderlineOffsetValue);
5018 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5020 // Test uniform values
5021 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5022 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5023 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5024 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5025 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5026 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5027 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5028 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5030 // Test unregistered visual
5031 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5032 DALI_TEST_CHECK(!property3.object);
5033 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5038 int UtcDaliVisualGetVisualProperty02(void)
5040 ToolkitTestApplication application;
5041 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5043 static std::vector<UniformData> customUniforms =
5045 UniformData("mixColor", Property::Type::VECTOR3),
5046 UniformData("offset", Property::Type::VECTOR2),
5047 UniformData("size", Property::Type::VECTOR2),
5048 UniformData("cornerRadius", Property::Type::VECTOR4),
5049 UniformData("borderlineWidth", Property::Type::FLOAT),
5050 UniformData("borderlineCOlor", Property::Type::VECTOR4),
5051 UniformData("borderlineOffset", Property::Type::FLOAT),
5052 UniformData("blurRadius", Property::Type::FLOAT),
5055 TestGraphicsController& graphics = application.GetGraphicsController();
5056 graphics.AddCustomUniforms(customUniforms);
5058 VisualFactory factory = VisualFactory::Get();
5059 Property::Map propertyMap;
5060 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5061 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5063 DummyControl dummyControl = DummyControl::New(true);
5064 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5065 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5066 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5067 application.GetScene().Add(dummyControl);
5069 application.SendNotification();
5070 application.Render();
5072 Vector3 targetColor(1.0f, 1.0f, 1.0f);
5073 Vector2 targetOffset(0.05f, 0.05f);
5074 Vector2 targetSize(1.1f, 1.1f);
5075 float targetOpacity = 0.5f;
5076 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5077 float targetBorderlineWidth = 77.7f;
5078 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5079 float targetBorderlineOffset = 1.0f;
5080 float targetBlurRadius = 10.0f;
5082 // Should work when the properties are not set before
5083 Animation animation = Animation::New(1.0f);
5084 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5085 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5086 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5087 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5088 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5089 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5090 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5091 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5092 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5095 application.SendNotification();
5096 application.Render();
5097 application.Render(1001u); // End of animation
5099 Property::Map resultMap;
5100 colorVisual.CreatePropertyMap(resultMap);
5102 // Test property values: they should be updated
5103 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5104 DALI_TEST_CHECK(colorValue);
5105 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5107 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5108 Dali::Property::Map* transformMap = transformValue->GetMap();
5109 DALI_TEST_CHECK(transformMap);
5111 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5112 DALI_TEST_CHECK(offsetValue);
5113 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5115 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5116 DALI_TEST_CHECK(sizeValue);
5117 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5119 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5120 DALI_TEST_CHECK(cornerRadiusValue);
5121 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5123 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5124 DALI_TEST_CHECK(borderlineWidthValue);
5125 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5127 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5128 DALI_TEST_CHECK(borderlineColorValue);
5129 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5131 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5132 DALI_TEST_CHECK(borderlineOffsetValue);
5133 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5135 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5136 DALI_TEST_CHECK(blurRadiusValue);
5137 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5139 // Test uniform values
5140 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5141 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5142 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5143 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5144 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5149 int UtcDaliVisualGetVisualProperty03(void)
5151 ToolkitTestApplication application;
5152 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5154 static std::vector<UniformData> customUniforms =
5156 UniformData("cornerRadius", Property::Type::VECTOR4),
5157 UniformData("borderlineWidth", Property::Type::FLOAT),
5158 UniformData("borderlineColor", Property::Type::VECTOR4),
5159 UniformData("borderlineOffset", Property::Type::FLOAT),
5162 TestGraphicsController& graphics = application.GetGraphicsController();
5163 graphics.AddCustomUniforms(customUniforms);
5165 VisualFactory factory = VisualFactory::Get();
5166 Property::Map propertyMap;
5167 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5168 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5170 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5172 DummyControl dummyControl = DummyControl::New(true);
5173 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5174 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5175 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5176 application.GetScene().Add(dummyControl);
5178 // Wait for image loading
5179 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5181 application.SendNotification();
5182 application.Render();
5184 float targetOpacity = 0.5f;
5185 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5186 float targetBorderlineWidth = 10.0f;
5187 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5188 float targetBorderlineOffset = -1.5f;
5190 Animation animation = Animation::New(1.0f);
5191 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5192 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5193 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5194 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5195 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5198 application.SendNotification();
5199 application.Render();
5200 application.Render(1001u); // End of animation
5202 Property::Map resultMap;
5203 imageVisual.CreatePropertyMap(resultMap);
5205 // Test property values: they should be updated
5206 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5207 DALI_TEST_CHECK(colorValue);
5208 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5210 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5211 DALI_TEST_CHECK(cornerRadiusValue);
5212 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5214 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5215 DALI_TEST_CHECK(borderlineWidthValue);
5216 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5218 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5219 DALI_TEST_CHECK(borderlineColorValue);
5220 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5222 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5223 DALI_TEST_CHECK(borderlineOffsetValue);
5224 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5226 // Test uniform value
5227 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5228 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5229 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5230 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5235 int UtcDaliVisualGetVisualProperty04(void)
5237 ToolkitTestApplication application;
5238 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5240 static std::vector<UniformData> customUniforms =
5242 UniformData("cornerRadius", Property::Type::VECTOR4),
5245 TestGraphicsController& graphics = application.GetGraphicsController();
5246 graphics.AddCustomUniforms(customUniforms);
5248 Vector2 start(-1.f, -1.f);
5249 Vector2 end(1.f, 1.f);
5250 Property::Array stopColors;
5251 stopColors.PushBack(Color::RED);
5252 stopColors.PushBack(Color::GREEN);
5254 VisualFactory factory = VisualFactory::Get();
5255 Property::Map propertyMap;
5256 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5257 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5258 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5259 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5260 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5261 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5262 Visual::Base gradientVisual = 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, gradientVisual);
5267 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5268 application.GetScene().Add(dummyControl);
5270 application.SendNotification();
5271 application.Render();
5273 float targetOpacity = 0.5f;
5274 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5276 Animation animation = Animation::New(1.0f);
5277 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5278 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5281 application.SendNotification();
5282 application.Render();
5283 application.Render(1001u); // End of animation
5285 Property::Map resultMap;
5286 gradientVisual.CreatePropertyMap(resultMap);
5288 // Test property values: they should be updated
5289 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5290 DALI_TEST_CHECK(colorValue);
5291 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5293 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5294 DALI_TEST_CHECK(cornerRadiusValue);
5295 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5297 // Test uniform value
5298 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5303 int UtcDaliVisualGetVisualProperty05(void)
5305 ToolkitTestApplication application;
5306 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5308 static std::vector<UniformData> customUniforms =
5310 UniformData("cornerRadius", Property::Type::VECTOR4),
5311 UniformData("borderlineWidth", Property::Type::FLOAT),
5312 UniformData("borderlineColor", Property::Type::VECTOR4),
5313 UniformData("borderlineOffset", Property::Type::FLOAT),
5316 TestGraphicsController& graphics = application.GetGraphicsController();
5317 graphics.AddCustomUniforms(customUniforms);
5319 VisualFactory factory = VisualFactory::Get();
5320 Property::Map propertyMap;
5321 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5322 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5324 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5326 DummyControl dummyControl = DummyControl::New(true);
5327 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5328 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5329 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5330 application.GetScene().Add(dummyControl);
5332 application.SendNotification();
5333 application.Render();
5335 // Wait for loading & rasterization
5336 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5338 application.SendNotification();
5339 application.Render();
5341 float targetOpacity = 0.5f;
5342 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5343 float targetBorderlineWidth = 10.0f;
5344 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5345 float targetBorderlineOffset = -1.5f;
5347 Animation animation = Animation::New(1.0f);
5348 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5349 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5350 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5351 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5352 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5355 application.SendNotification();
5356 application.Render();
5357 application.Render(1001u); // End of animation
5359 Property::Map resultMap;
5360 svgVisual.CreatePropertyMap(resultMap);
5362 // Test property values: they should be updated
5363 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5364 DALI_TEST_CHECK(colorValue);
5365 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5367 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5368 DALI_TEST_CHECK(cornerRadiusValue);
5369 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5371 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5372 DALI_TEST_CHECK(borderlineWidthValue);
5373 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5375 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5376 DALI_TEST_CHECK(borderlineColorValue);
5377 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5379 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5380 DALI_TEST_CHECK(borderlineOffsetValue);
5381 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5383 // Currently test with multiple program doesn't work well. will fix another day
5384 // Test uniform value
5385 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5386 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5387 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5388 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5393 int UtcDaliVisualGetVisualProperty06(void)
5395 ToolkitTestApplication application;
5396 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5398 static std::vector<UniformData> customUniforms =
5400 UniformData("cornerRadius", Property::Type::VECTOR4),
5401 UniformData("borderlineWidth", Property::Type::FLOAT),
5402 UniformData("borderlineColor", Property::Type::VECTOR4),
5403 UniformData("borderlineOffset", Property::Type::FLOAT),
5406 TestGraphicsController& graphics = application.GetGraphicsController();
5407 graphics.AddCustomUniforms(customUniforms);
5409 VisualFactory factory = VisualFactory::Get();
5410 Property::Map propertyMap;
5411 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5412 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5414 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5416 DummyControl dummyControl = DummyControl::New(true);
5417 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5418 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5419 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5420 application.GetScene().Add(dummyControl);
5422 application.SendNotification();
5423 application.Render();
5425 // Wait for image loading
5426 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5428 application.SendNotification();
5429 application.Render();
5431 float targetOpacity = 0.5f;
5432 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5433 float targetBorderlineWidth = 10.0f;
5434 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5435 float targetBorderlineOffset = -1.5f;
5437 Animation animation = Animation::New(1.0f);
5438 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5439 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5440 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5441 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5442 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5445 application.SendNotification();
5446 application.Render();
5447 application.Render(1001u); // End of animation
5449 Property::Map resultMap;
5450 animatedImageVisual.CreatePropertyMap(resultMap);
5452 // Test property values: they should be updated
5453 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5454 DALI_TEST_CHECK(colorValue);
5455 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5457 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5458 DALI_TEST_CHECK(cornerRadiusValue);
5459 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5461 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5462 DALI_TEST_CHECK(borderlineWidthValue);
5463 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5465 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5466 DALI_TEST_CHECK(borderlineColorValue);
5467 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5469 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5470 DALI_TEST_CHECK(borderlineOffsetValue);
5471 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5473 // Currently test with multiple program doesn't work well. will fix another day
5474 // Test uniform value
5475 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5476 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5477 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5478 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5483 int UtcDaliVisualGetVisualProperty07(void)
5485 ToolkitTestApplication application;
5486 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5488 static std::vector<UniformData> customUniforms =
5490 UniformData("cornerRadius", Property::Type::VECTOR4),
5491 UniformData("borderlineWidth", Property::Type::FLOAT),
5492 UniformData("borderlineColor", Property::Type::VECTOR4),
5493 UniformData("borderlineOffset", Property::Type::FLOAT),
5496 TestGraphicsController& graphics = application.GetGraphicsController();
5497 graphics.AddCustomUniforms(customUniforms);
5499 VisualFactory factory = VisualFactory::Get();
5500 Property::Map propertyMap;
5501 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5502 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5504 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5506 DummyControl dummyControl = DummyControl::New(true);
5507 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5508 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5509 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5510 application.GetScene().Add(dummyControl);
5512 application.SendNotification();
5513 application.Render();
5515 // Wait for image loading
5516 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5518 application.SendNotification();
5519 application.Render();
5521 float targetOpacity = 0.5f;
5522 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5523 float targetBorderlineWidth = 10.0f;
5524 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5525 float targetBorderlineOffset = -1.5f;
5527 Animation animation = Animation::New(1.0f);
5528 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5529 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5530 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5531 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5532 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5535 application.SendNotification();
5536 application.Render();
5537 application.Render(1001u); // End of animation
5539 Property::Map resultMap;
5540 animatedVectorVisual.CreatePropertyMap(resultMap);
5542 // Test property values: they should be updated
5543 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5544 DALI_TEST_CHECK(colorValue);
5545 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5547 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5548 DALI_TEST_CHECK(cornerRadiusValue);
5549 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5551 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5552 DALI_TEST_CHECK(borderlineWidthValue);
5553 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5555 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5556 DALI_TEST_CHECK(borderlineColorValue);
5557 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5559 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5560 DALI_TEST_CHECK(borderlineOffsetValue);
5561 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5563 // Currently test with multiple program doesn't work well. will fix another day
5564 // Test uniform value
5565 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5566 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5567 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5568 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5573 int UtcDaliVisualUpdateProperty(void)
5575 ToolkitTestApplication application;
5576 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5578 VisualFactory factory = VisualFactory::Get();
5579 Property::Map propertyMap;
5580 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5581 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5582 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5583 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5585 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5587 DummyControl dummyControl = DummyControl::New(true);
5588 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5589 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5590 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5591 application.GetScene().Add(dummyControl);
5593 application.SendNotification();
5594 application.Render();
5596 // Wait for image loading
5597 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5599 application.SendNotification();
5600 application.Render();
5602 Property::Map originalMap;
5603 imageVisual.CreatePropertyMap(originalMap);
5605 float targetOpacity = 0.5f;
5606 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5607 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5608 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5610 Property::Map targetPropertyMap;
5611 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5612 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5613 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5614 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5615 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5617 // Update Properties
5618 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5620 Property::Map resultMap;
5621 imageVisual.CreatePropertyMap(resultMap);
5623 // Test property values: they should be updated
5624 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5625 DALI_TEST_CHECK(colorValue);
5626 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5628 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5629 DALI_TEST_CHECK(urlValue);
5630 // NOTE : ImageVisual URL must NOT changed.
5631 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5633 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5634 DALI_TEST_CHECK(preMultipliedValue);
5635 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5637 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5638 DALI_TEST_CHECK(visualFittingModeValue);
5639 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5644 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5646 ToolkitTestApplication application;
5647 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5649 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5651 VisualFactory factory = VisualFactory::Get();
5652 Property::Map propertyMap;
5654 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5655 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5657 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5659 DummyControl dummyControl = DummyControl::New(true);
5660 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5661 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5662 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5663 application.GetScene().Add(dummyControl);
5665 application.SendNotification();
5666 application.Render();
5668 // Wait for image loading
5669 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5671 application.SendNotification();
5672 application.Render();
5676 Renderer renderer = dummyControl.GetRendererAt(0);
5677 Shader shader = renderer.GetShader();
5678 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5679 Property::Map* map = value.GetMap();
5680 DALI_TEST_CHECK(map);
5682 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5683 DALI_TEST_CHECK(fragment);
5684 std::string fragmentShader;
5685 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5686 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5687 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5689 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5690 std::string vertexShader;
5691 DALI_TEST_CHECK(vertex->Get(vertexShader));
5692 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5693 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5696 callStack.Enable(true);
5698 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5700 Property::Map targetPropertyMap;
5701 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5702 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5704 // Update Properties with CornerRadius
5705 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5707 Property::Map resultMap;
5708 imageVisual.CreatePropertyMap(resultMap);
5710 // Test property values: they should be updated
5711 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5712 DALI_TEST_CHECK(cornerRadiusValue);
5713 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5715 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5716 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5717 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5721 Renderer renderer = dummyControl.GetRendererAt(0);
5722 Shader shader = renderer.GetShader();
5723 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5724 Property::Map* map = value.GetMap();
5725 DALI_TEST_CHECK(map);
5727 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5728 DALI_TEST_CHECK(fragment);
5729 std::string fragmentShader;
5730 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5731 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5732 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5734 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5735 std::string vertexShader;
5736 DALI_TEST_CHECK(vertex->Get(vertexShader));
5737 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5738 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5741 // Send shader compile signal
5742 application.SendNotification();
5743 application.Render();
5745 callStack.Enable(false);
5747 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5749 callStack.Enable(true);
5751 float targetBorderlineWidth = 10.0f;
5752 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5753 float targetBorderlineOffset = -0.3f;
5755 Property::Map targetPropertyMap2;
5756 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5757 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5758 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5759 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5760 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5762 // Update Properties with Borderline
5763 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5765 Property::Map resultMap2;
5766 imageVisual.CreatePropertyMap(resultMap2);
5768 // Test property values: they should be updated
5769 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5770 DALI_TEST_CHECK(cornerRadiusValue);
5771 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5773 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5774 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5775 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5777 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5778 DALI_TEST_CHECK(borderlineWidthValue);
5779 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5781 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5782 DALI_TEST_CHECK(borderlineColorValue);
5783 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5785 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5786 DALI_TEST_CHECK(borderlineOffsetValue);
5787 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5791 Renderer renderer = dummyControl.GetRendererAt(0);
5792 Shader shader = renderer.GetShader();
5793 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5794 Property::Map* map = value.GetMap();
5795 DALI_TEST_CHECK(map);
5797 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5798 DALI_TEST_CHECK(fragment);
5799 std::string fragmentShader;
5800 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5801 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5802 // Note : mAlwaysUsingCornerRadius is true.
5803 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5805 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5806 std::string vertexShader;
5807 DALI_TEST_CHECK(vertex->Get(vertexShader));
5808 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5809 // Note : mAlwaysUsingCornerRadius is true.
5810 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5813 // Send shader compile signal
5814 application.SendNotification();
5815 application.Render();
5817 callStack.Enable(false);
5819 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5821 callStack.Enable(true);
5823 Property::Map targetPropertyMap3;
5824 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5825 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5826 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5827 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5828 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5830 // Update Properties into zero
5831 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5833 Property::Map resultMap3;
5834 imageVisual.CreatePropertyMap(resultMap3);
5836 // Test property values: they should be updated
5837 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5838 DALI_TEST_CHECK(cornerRadiusValue);
5839 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5841 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5842 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5843 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5845 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5846 DALI_TEST_CHECK(borderlineWidthValue);
5847 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5849 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5850 DALI_TEST_CHECK(borderlineColorValue);
5851 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5853 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5854 DALI_TEST_CHECK(borderlineOffsetValue);
5855 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5859 Renderer renderer = dummyControl.GetRendererAt(0);
5860 Shader shader = renderer.GetShader();
5861 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5862 Property::Map* map = value.GetMap();
5863 DALI_TEST_CHECK(map);
5865 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5866 DALI_TEST_CHECK(fragment);
5867 std::string fragmentShader;
5868 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5869 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5870 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5871 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5873 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5874 std::string vertexShader;
5875 DALI_TEST_CHECK(vertex->Get(vertexShader));
5876 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5877 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5878 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5881 // Send shader compile signal
5882 application.SendNotification();
5883 application.Render();
5885 callStack.Enable(false);
5886 // Shader not changed
5887 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5892 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5894 ToolkitTestApplication application;
5895 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5897 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5899 VisualFactory factory = VisualFactory::Get();
5900 Property::Map propertyMap;
5902 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5903 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5905 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5907 DummyControl dummyControl = DummyControl::New(true);
5908 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5909 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5910 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5911 application.GetScene().Add(dummyControl);
5913 application.SendNotification();
5914 application.Render();
5916 // Wait for image loading
5917 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5919 application.SendNotification();
5920 application.Render();
5924 Renderer renderer = dummyControl.GetRendererAt(0);
5925 Shader shader = renderer.GetShader();
5926 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5927 Property::Map* map = value.GetMap();
5928 DALI_TEST_CHECK(map);
5930 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5931 DALI_TEST_CHECK(fragment);
5932 std::string fragmentShader;
5933 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5934 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5935 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5937 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5938 std::string vertexShader;
5939 DALI_TEST_CHECK(vertex->Get(vertexShader));
5940 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5941 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5944 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5946 Property::Map targetPropertyMap;
5947 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5950 callStack.Enable(true);
5952 // Update Properties with CornerRadius
5953 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5955 Property::Map resultMap;
5956 imageVisual.CreatePropertyMap(resultMap);
5958 // Test property values: they should be updated
5959 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5960 DALI_TEST_CHECK(cornerRadiusValue);
5961 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5965 Renderer renderer = dummyControl.GetRendererAt(0);
5966 Shader shader = renderer.GetShader();
5967 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5968 Property::Map* map = value.GetMap();
5969 DALI_TEST_CHECK(map);
5971 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5972 DALI_TEST_CHECK(fragment);
5973 std::string fragmentShader;
5974 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5975 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5976 // Note : corner radius is zero. so we don't change shader!
5977 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5979 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5980 std::string vertexShader;
5981 DALI_TEST_CHECK(vertex->Get(vertexShader));
5982 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5983 // Note : corner radius is zero. so we don't change shader!
5984 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5987 // Send shader compile signal
5988 application.SendNotification();
5989 application.Render();
5991 callStack.Enable(false);
5993 // Shader doesn't changed
5994 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5996 callStack.Enable(true);
5998 float targetBorderlineWidth = 0.0f;
5999 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
6000 float targetBorderlineOffset = -1.0f;
6002 Property::Map targetPropertyMap2;
6003 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6004 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
6005 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6007 // Update Properties with Borderline
6008 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6010 Property::Map resultMap2;
6011 imageVisual.CreatePropertyMap(resultMap2);
6013 // Test property values: they should be updated
6014 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6015 DALI_TEST_CHECK(borderlineWidthValue);
6016 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6018 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6019 DALI_TEST_CHECK(borderlineColorValue);
6020 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6022 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6023 DALI_TEST_CHECK(borderlineOffsetValue);
6024 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6028 Renderer renderer = dummyControl.GetRendererAt(0);
6029 Shader shader = renderer.GetShader();
6030 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6031 Property::Map* map = value.GetMap();
6032 DALI_TEST_CHECK(map);
6034 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6035 DALI_TEST_CHECK(fragment);
6036 std::string fragmentShader;
6037 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6038 // Note : borderline width is zero. so we don't change shader!
6039 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6040 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6042 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6043 std::string vertexShader;
6044 DALI_TEST_CHECK(vertex->Get(vertexShader));
6045 // Note : borderline width is zero. so we don't change shader!
6046 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6047 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6050 // Send shader compile signal
6051 application.SendNotification();
6052 application.Render();
6054 callStack.Enable(false);
6056 // Shader doesn't changed
6057 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6062 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6064 ToolkitTestApplication application;
6065 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6067 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6069 VisualFactory factory = VisualFactory::Get();
6070 Property::Map propertyMap;
6072 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
6073 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6075 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6077 DummyControl dummyControl = DummyControl::New(true);
6078 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6079 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6080 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6081 application.GetScene().Add(dummyControl);
6083 application.SendNotification();
6084 application.Render();
6086 application.SendNotification();
6087 application.Render();
6091 Renderer renderer = dummyControl.GetRendererAt(0);
6092 Shader shader = renderer.GetShader();
6093 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6094 Property::Map* map = value.GetMap();
6095 DALI_TEST_CHECK(map);
6097 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6098 DALI_TEST_CHECK(fragment);
6099 std::string fragmentShader;
6100 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6101 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6102 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6103 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6105 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6106 std::string vertexShader;
6107 DALI_TEST_CHECK(vertex->Get(vertexShader));
6108 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6109 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6110 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6113 float targetBlurRadius = 15.0f;
6114 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6116 Property::Map targetPropertyMap;
6117 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6118 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6119 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6122 callStack.Enable(true);
6124 // Update Properties with CornerRadius
6125 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6127 Property::Map resultMap;
6128 imageVisual.CreatePropertyMap(resultMap);
6130 // Test property values: they should be updated
6131 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6132 DALI_TEST_CHECK(blurRadiusValue);
6133 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6135 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6136 DALI_TEST_CHECK(cornerRadiusValue);
6137 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6141 Renderer renderer = dummyControl.GetRendererAt(0);
6142 Shader shader = renderer.GetShader();
6143 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6144 Property::Map* map = value.GetMap();
6145 DALI_TEST_CHECK(map);
6147 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6148 DALI_TEST_CHECK(fragment);
6149 std::string fragmentShader;
6150 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6151 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6152 // Note : We ignore borderline when blur radius occured
6153 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6154 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6156 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6157 std::string vertexShader;
6158 DALI_TEST_CHECK(vertex->Get(vertexShader));
6159 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6160 // Note : We ignore borderline when blur radius occured
6161 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6162 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6165 // Send shader compile signal
6166 application.SendNotification();
6167 application.Render();
6169 callStack.Enable(false);
6172 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6174 callStack.Enable(true);
6176 Property::Map targetPropertyMap2;
6177 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6178 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6179 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6181 // Update Properties with CornerRadius
6182 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6184 Property::Map resultMap2;
6185 imageVisual.CreatePropertyMap(resultMap2);
6187 // Test property values: they should be updated
6188 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6189 DALI_TEST_CHECK(blurRadiusValue);
6190 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6192 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6193 DALI_TEST_CHECK(cornerRadiusValue);
6194 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6198 Renderer renderer = dummyControl.GetRendererAt(0);
6199 Shader shader = renderer.GetShader();
6200 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6201 Property::Map* map = value.GetMap();
6202 DALI_TEST_CHECK(map);
6204 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6205 DALI_TEST_CHECK(fragment);
6206 std::string fragmentShader;
6207 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6208 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6209 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6210 // Note : We ignore borderline when blur radius occured
6211 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6212 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6214 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6215 std::string vertexShader;
6216 DALI_TEST_CHECK(vertex->Get(vertexShader));
6217 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6218 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6219 // Note : We ignore borderline when blur radius occured
6220 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6221 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6224 // Send shader compile signal
6225 application.SendNotification();
6226 application.Render();
6228 callStack.Enable(false);
6230 // Shader not changed
6231 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6236 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6238 ToolkitTestApplication application;
6239 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6241 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6243 VisualFactory factory = VisualFactory::Get();
6244 Property::Map propertyMap;
6246 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6247 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6248 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6250 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6252 DummyControl dummyControl = DummyControl::New(true);
6253 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6254 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6255 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6256 application.GetScene().Add(dummyControl);
6258 application.SendNotification();
6259 application.Render();
6261 // Wait for image loading
6262 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6264 application.SendNotification();
6265 application.Render();
6269 Renderer renderer = dummyControl.GetRendererAt(0);
6270 Shader shader = renderer.GetShader();
6271 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6272 Property::Map* map = value.GetMap();
6273 DALI_TEST_CHECK(map);
6275 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6276 DALI_TEST_CHECK(fragment);
6277 std::string fragmentShader;
6278 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6279 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6280 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6282 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6283 std::string vertexShader;
6284 DALI_TEST_CHECK(vertex->Get(vertexShader));
6285 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6286 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6289 callStack.Enable(true);
6291 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6293 Animation animation = Animation::New(1.0f);
6294 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6297 application.SendNotification();
6298 application.Render();
6299 application.Render(1001u); // End of animation
6303 Renderer renderer = dummyControl.GetRendererAt(0);
6304 Shader shader = renderer.GetShader();
6305 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6306 Property::Map* map = value.GetMap();
6307 DALI_TEST_CHECK(map);
6309 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6310 DALI_TEST_CHECK(fragment);
6311 std::string fragmentShader;
6312 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6313 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6314 // Note : mAlwaysUsingCornerRadius is true.
6315 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6317 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6318 std::string vertexShader;
6319 DALI_TEST_CHECK(vertex->Get(vertexShader));
6320 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6321 // Note : mAlwaysUsingCornerRadius is true.
6322 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6324 callStack.Enable(false);
6325 // Shader not changed
6326 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6328 callStack.Enable(true);
6330 float targetBorderlineWidth = 10.0f;
6331 Property::Map targetPropertyMap;
6332 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6334 // Update Properties with CornerRadius
6335 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6337 Property::Map resultMap;
6338 imageVisual.CreatePropertyMap(resultMap);
6340 // Test property values: they should be updated
6341 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6342 DALI_TEST_CHECK(cornerRadiusValue);
6343 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6345 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6346 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6347 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6349 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6350 DALI_TEST_CHECK(borderlineWidthValue);
6351 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6355 Renderer renderer = dummyControl.GetRendererAt(0);
6356 Shader shader = renderer.GetShader();
6357 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6358 Property::Map* map = value.GetMap();
6359 DALI_TEST_CHECK(map);
6361 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6362 DALI_TEST_CHECK(fragment);
6363 std::string fragmentShader;
6364 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6365 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6366 // Note : mAlwaysUsingCornerRadius is true.
6367 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6369 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6370 std::string vertexShader;
6371 DALI_TEST_CHECK(vertex->Get(vertexShader));
6372 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6373 // Note : mAlwaysUsingCornerRadius is true.
6374 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6377 // Send shader compile signal
6378 application.SendNotification();
6379 application.Render();
6381 callStack.Enable(false);
6383 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));