2 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <dali-toolkit-test-suite-utils.h>
22 #include <dali-toolkit/dali-toolkit.h>
23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
24 #include <dali-toolkit/devel-api/controls/control-devel.h>
25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
29 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
34 #include <dali/devel-api/actors/actor-devel.h>
35 #include <dali/devel-api/object/handle-devel.h>
36 #include <dali/devel-api/text-abstraction/font-client.h>
37 #include <toolkit-event-thread-callback.h>
39 #include "dummy-control.h"
42 using namespace Dali::Toolkit;
46 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
47 const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
48 const char* TEST_NPATCH_FILE_NAME = TEST_RESOURCE_DIR "/button-up.9.png";
49 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
50 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
51 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
53 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
57 Property::Map DefaultTransform()
59 Property::Map transformMap;
61 .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
62 .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
63 .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
64 .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
65 .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
66 .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
72 if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
74 for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
76 const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
78 Property::Value* valueSet = NULL;
79 if(valueGet.first.type == Property::Key::INDEX)
81 valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
85 // Get Key is a string so searching Set Map for a string key
86 valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
91 if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
93 tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
96 else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
98 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
101 else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
103 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
106 else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
108 tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
111 else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
113 Vector2 vector2Get = valueGet.second.Get<Vector2>();
114 Vector2 vector2Set = valueSet->Get<Vector2>();
115 tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
118 else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
120 Vector4 vector4Get = valueGet.second.Get<Vector4>();
121 Vector4 vector4Set = valueSet->Get<Vector4>();
122 tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
128 if(valueGet.first.type == Property::Key::INDEX)
130 tet_printf(" The key %d doesn't exist.", valueGet.first.indexKey);
134 tet_printf(" The key %s doesn't exist.", valueGet.first.stringKey.c_str());
146 void dali_visual_startup(void)
148 test_return_value = TET_UNDEF;
151 void dali_visual_cleanup(void)
153 test_return_value = TET_PASS;
156 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
159 visual.CreatePropertyMap(map);
160 Property::Value* value = map.Find(mixColorIndex);
161 DALI_TEST_CHECK(value);
163 DALI_TEST_CHECK(value->Get(mixColor1));
164 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
166 value = map.Find(Visual::Property::MIX_COLOR);
167 DALI_TEST_CHECK(value);
169 DALI_TEST_CHECK(value->Get(mixColor2));
170 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
172 value = map.Find(Visual::Property::OPACITY);
173 DALI_TEST_CHECK(value);
175 DALI_TEST_CHECK(value->Get(opacity));
176 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
179 int UtcDaliVisualCopyAndAssignment(void)
181 ToolkitTestApplication application;
182 tet_infoline("UtcDaliVisualCopyAndAssignment");
184 VisualFactory factory = VisualFactory::Get();
185 Property::Map propertyMap;
186 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
187 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
188 Visual::Base visual = factory.CreateVisual(propertyMap);
190 Visual::Base visualCopy(visual);
191 DALI_TEST_CHECK(visual == visualCopy);
193 Visual::Base emptyVisual;
194 Visual::Base emptyVisualCopy(emptyVisual);
195 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
197 Visual::Base visualEquals;
198 visualEquals = visual;
199 DALI_TEST_CHECK(visual == visualEquals);
201 Visual::Base emptyVisualEquals;
202 emptyVisualEquals = emptyVisual;
203 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
207 DALI_TEST_CHECK(visual = visualCopy);
212 int UtcDaliVisualSetName01(void)
214 ToolkitTestApplication application;
215 tet_infoline("UtcDaliVisualSetName");
217 VisualFactory factory = VisualFactory::Get();
218 Property::Map propertyMap;
219 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
220 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
221 Visual::Base visual = factory.CreateVisual(propertyMap);
223 const char* visualName = "backgroundVisual";
224 visual.SetName(visualName);
226 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
231 int UtcDaliVisualSetGetDepthIndex(void)
233 ToolkitTestApplication application;
234 tet_infoline("UtcDaliVisualSetDepthIndex");
236 VisualFactory factory = VisualFactory::Get();
237 Property::Map propertyMap;
238 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
239 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
240 Visual::Base visual = factory.CreateVisual(propertyMap);
242 visual.SetDepthIndex(1);
244 DummyControl dummyControl = DummyControl::New(true);
245 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
246 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
248 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
249 application.GetScene().Add(dummyControl);
251 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
252 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
253 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
255 visual.SetDepthIndex(-1);
256 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
257 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
258 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
263 int UtcDaliVisualSize(void)
265 ToolkitTestApplication application;
266 tet_infoline("UtcDaliVisualSize");
268 VisualFactory factory = VisualFactory::Get();
269 Vector2 controlSize(20.f, 30.f);
273 Dali::Property::Map map;
274 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
275 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
277 Visual::Base colorVisual = factory.CreateVisual(map);
278 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
280 colorVisual.GetNaturalSize(naturalSize);
281 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
285 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
286 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
287 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
288 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
289 Visual::Base imageVisual = factory.CreateVisual(map);
290 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
292 imageVisual.GetNaturalSize(naturalSize);
293 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
295 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
298 float borderSize = 5.f;
300 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
301 map[BorderVisual::Property::COLOR] = Color::RED;
302 map[BorderVisual::Property::SIZE] = borderSize;
303 Visual::Base borderVisual = factory.CreateVisual(map);
304 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
305 borderVisual.GetNaturalSize(naturalSize);
306 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
308 // gradient gradientVisual
309 Property::Map propertyMap;
310 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
311 Vector2 start(-1.f, -1.f);
312 Vector2 end(1.f, 1.f);
313 propertyMap.Insert("mixColor", Color::MAGENTA);
314 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
315 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
316 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
317 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
318 Property::Array stopColors;
319 stopColors.PushBack(Color::RED);
320 stopColors.PushBack(Color::GREEN);
321 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
322 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
323 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
324 gradientVisual.GetNaturalSize(naturalSize);
325 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
327 // animated gradient visual
328 Vector2 animated_gradient_visual_size(10.f, 10.f);
330 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
331 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
332 animatedGradientVisual.GetNaturalSize(naturalSize);
333 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
334 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
337 Visual::Base svgVisual = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
338 svgVisual.GetNaturalSize(naturalSize);
340 // <svg width="100" height="100">
341 // <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
343 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION);
345 // svg visual with a size
346 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(200, 200));
347 svgVisual2.GetNaturalSize(naturalSize);
348 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION); // Natural size should still be 100, 100
352 // Load some fonts to get the same metrics on different platforms.
353 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
354 fontClient.SetDpi(96u, 96u);
356 char* pathNamePtr = get_current_dir_name();
357 const std::string pathName(pathNamePtr);
360 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
362 // Create a TextVisual with a font size of 12 first
364 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
365 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
366 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
367 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
369 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
370 Vector2 smallTextVisualNaturalSize;
371 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
373 // Then create a TextVisual with a font size of 20
374 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
375 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
376 Vector2 largeTextVisualNaturalSize;
377 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
379 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
380 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
381 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
383 // The height returned for a particular width should also be greater for the large text visual
384 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
386 //AnimatedImageVisual
387 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
388 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
389 animatedImageVisual.GetNaturalSize(naturalSize);
390 // TEST_GIF_FILE: anim.gif
391 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
392 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
397 int UtcDaliVisualSetOnOffScene(void)
399 ToolkitTestApplication application;
400 tet_infoline("UtcDaliVisualSetOnOffScene");
402 VisualFactory factory = VisualFactory::Get();
403 Property::Map propertyMap;
404 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
405 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
406 Visual::Base visual = factory.CreateVisual(propertyMap);
408 DummyControl actor = DummyControl::New(true);
409 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
410 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
412 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
414 application.SendNotification();
415 application.Render(0);
416 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
418 application.GetScene().Add(actor);
420 application.SendNotification();
421 application.Render(0);
422 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
424 application.GetScene().Remove(actor);
426 application.SendNotification();
427 application.Render(0);
428 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
433 int UtcDaliVisualSetOnOffScene2(void)
435 ToolkitTestApplication application;
436 tet_infoline("UtcDaliVisualSetOnOffScene2");
438 VisualFactory factory = VisualFactory::Get();
439 Property::Map propertyMap;
440 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
441 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
442 Visual::Base visual = factory.CreateVisual(propertyMap);
444 DummyControl actor = DummyControl::New(true);
445 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
446 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
448 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
450 application.SendNotification();
451 application.Render(0);
452 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
455 application.GetScene().Add(actor);
457 application.SendNotification();
458 application.Render(0);
459 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
460 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
461 Renderer renderer = actor.GetRendererAt(0);
462 auto textures = renderer.GetTextures();
463 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
465 application.GetScene().Remove(actor);
467 application.SendNotification();
468 application.Render(0);
469 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
472 application.GetScene().Add(actor);
474 application.SendNotification();
475 application.Render(0);
476 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
477 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
478 renderer = actor.GetRendererAt(0);
479 textures = renderer.GetTextures();
480 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
482 application.GetScene().Remove(actor);
484 application.SendNotification();
485 application.Render(0);
486 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
491 int UtcDaliVisualGetPropertyMap1(void)
493 ToolkitTestApplication application;
494 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
496 VisualFactory factory = VisualFactory::Get();
497 Property::Map propertyMap;
498 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
499 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
500 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
501 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
502 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
503 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
504 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
505 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
506 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
508 Property::Map resultMap;
509 colorVisual.CreatePropertyMap(resultMap);
511 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
512 DALI_TEST_CHECK(typeValue);
513 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
515 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
516 DALI_TEST_CHECK(colorValue);
517 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
519 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
520 DALI_TEST_CHECK(cornerRadiusValue);
521 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
523 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
524 DALI_TEST_CHECK(cornerRadiusPolicyValue);
525 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
527 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
528 DALI_TEST_CHECK(borderlineWidthValue);
529 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
531 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
532 DALI_TEST_CHECK(borderlineColorValue);
533 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
535 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
536 DALI_TEST_CHECK(borderlineOffsetValue);
537 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
539 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
540 DALI_TEST_CHECK(blurRadiusValue);
541 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
543 // change the blend color
544 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
545 colorVisual = factory.CreateVisual(propertyMap);
546 colorVisual.CreatePropertyMap(resultMap);
548 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
549 DALI_TEST_CHECK(colorValue);
550 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
553 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
555 colorVisual = factory.CreateVisual(propertyMap);
556 colorVisual.CreatePropertyMap(resultMap);
558 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
559 DALI_TEST_CHECK(blurRadiusValue);
560 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
565 int UtcDaliVisualGetPropertyMap2(void)
567 ToolkitTestApplication application;
568 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
570 VisualFactory factory = VisualFactory::Get();
571 Property::Map propertyMap;
572 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
573 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
574 propertyMap.Insert("borderColor", Color::BLUE);
575 propertyMap.Insert("borderSize", 5.f);
576 propertyMap.Insert("antiAliasing", true);
577 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
579 Property::Map resultMap;
580 borderVisual.CreatePropertyMap(resultMap);
582 // check the property values from the returned map from visual
583 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
584 DALI_TEST_CHECK(typeValue);
585 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
587 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
588 DALI_TEST_CHECK(colorValue);
589 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
591 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
592 DALI_TEST_CHECK(sizeValue);
593 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
595 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
596 DALI_TEST_CHECK(AAValue);
597 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
599 Property::Map propertyMap1;
600 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
601 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
602 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
603 borderVisual = factory.CreateVisual(propertyMap1);
604 borderVisual.CreatePropertyMap(resultMap);
606 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
607 DALI_TEST_CHECK(typeValue);
608 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
610 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
611 DALI_TEST_CHECK(colorValue);
612 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
614 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
615 DALI_TEST_CHECK(sizeValue);
616 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
618 // Get default value of borderline values here
620 sizeValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
621 DALI_TEST_CHECK(sizeValue);
622 DALI_TEST_CHECK(sizeValue->Get<float>() == 0.0f);
624 colorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
625 DALI_TEST_CHECK(colorValue);
626 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLACK);
628 sizeValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
629 DALI_TEST_CHECK(sizeValue);
630 DALI_TEST_CHECK(sizeValue->Get<float>() == 0.0f);
635 int UtcDaliVisualGetPropertyMap2N(void)
637 ToolkitTestApplication application;
638 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
640 VisualFactory factory = VisualFactory::Get();
641 Property::Map propertyMap;
642 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
643 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
645 tet_infoline("Test that the visual is created, with a default renderer");
646 DALI_TEST_CHECK(borderVisual);
648 DummyControl dummyControl = DummyControl::New(true);
649 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
650 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
651 application.GetScene().Add(dummyControl);
653 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
658 int UtcDaliVisualGetPropertyMap3(void)
660 ToolkitTestApplication application;
661 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
663 VisualFactory factory = VisualFactory::Get();
664 DALI_TEST_CHECK(factory);
666 Property::Map propertyMap;
667 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
669 Vector2 start(-1.f, -1.f);
670 Vector2 end(1.f, 1.f);
671 propertyMap.Insert("startPosition", start);
672 propertyMap.Insert("endPosition", end);
673 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
675 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
677 Property::Array stopColors;
678 stopColors.PushBack(Color::RED);
679 stopColors.PushBack(Color::GREEN);
680 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
682 float borderlineWidth = 4.0f;
683 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
684 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
685 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
687 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
689 Property::Map resultMap;
690 gradientVisual.CreatePropertyMap(resultMap);
692 // check the property values from the returned map from visual
693 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
694 DALI_TEST_CHECK(value);
695 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
697 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
698 DALI_TEST_CHECK(value);
699 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
701 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
702 DALI_TEST_CHECK(value);
703 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
705 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
706 DALI_TEST_CHECK(value);
707 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
709 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
710 DALI_TEST_CHECK(value);
711 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
713 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
714 DALI_TEST_CHECK(value);
715 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
717 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
718 DALI_TEST_CHECK(value);
719 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
721 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
722 DALI_TEST_CHECK(value);
723 Property::Array* offsetArray = value->GetArray();
724 DALI_TEST_CHECK(offsetArray->Count() == 2);
725 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
726 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
728 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
729 DALI_TEST_CHECK(value);
730 Property::Array* colorArray = value->GetArray();
731 DALI_TEST_CHECK(colorArray->Count() == 2);
732 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
733 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
738 int UtcDaliVisualGetPropertyMap4(void)
740 ToolkitTestApplication application;
741 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
743 VisualFactory factory = VisualFactory::Get();
744 DALI_TEST_CHECK(factory);
746 Property::Map propertyMap;
747 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
749 Vector2 center(100.f, 100.f);
750 float radius = 100.f;
751 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
752 propertyMap.Insert(GradientVisual::Property::CENTER, center);
753 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
754 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
756 Property::Array stopColors;
757 stopColors.PushBack(Color::RED);
758 stopColors.PushBack(Color::BLACK);
759 stopColors.PushBack(Color::GREEN);
760 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
762 float borderlineWidth = 8.0f;
763 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
764 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
765 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
767 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
768 DALI_TEST_CHECK(gradientVisual);
770 Property::Map resultMap;
771 gradientVisual.CreatePropertyMap(resultMap);
773 // check the property values from the returned map from visual
774 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
775 DALI_TEST_CHECK(value);
776 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
778 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
779 DALI_TEST_CHECK(value);
780 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
782 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
783 DALI_TEST_CHECK(value);
784 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
786 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
787 DALI_TEST_CHECK(value);
788 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
790 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
791 DALI_TEST_CHECK(value);
792 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
794 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
795 DALI_TEST_CHECK(value);
796 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
798 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
799 DALI_TEST_CHECK(value);
800 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
802 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
803 DALI_TEST_CHECK(value);
804 Property::Array* offsetArray = value->GetArray();
805 DALI_TEST_CHECK(offsetArray->Count() == 3);
806 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
807 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
808 // any stop value will be clamped to [0.0, 1.0];
809 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
811 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
812 DALI_TEST_CHECK(value);
813 Property::Array* colorArray = value->GetArray();
814 DALI_TEST_CHECK(colorArray->Count() == 3);
815 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
816 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
817 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
822 int UtcDaliVisualGetPropertyMap5(void)
824 ToolkitTestApplication application;
825 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
827 VisualFactory factory = VisualFactory::Get();
828 Property::Map propertyMap;
829 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
830 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
831 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
832 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
833 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
834 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
835 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
836 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
837 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
838 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
839 propertyMap.Insert("synchronousLoading", true);
841 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
842 DALI_TEST_CHECK(imageVisual);
844 Property::Map resultMap;
845 imageVisual.CreatePropertyMap(resultMap);
847 // check the property values from the returned map from visual
848 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
849 DALI_TEST_CHECK(value);
850 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
852 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
853 DALI_TEST_CHECK(value);
854 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
856 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
857 DALI_TEST_CHECK(value);
858 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
860 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
861 DALI_TEST_CHECK(value);
862 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
864 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
865 DALI_TEST_CHECK(value);
866 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
868 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
869 DALI_TEST_CHECK(value);
870 DALI_TEST_CHECK(value->Get<int>() == 20);
872 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
873 DALI_TEST_CHECK(value);
874 DALI_TEST_CHECK(value->Get<int>() == 30);
876 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
877 DALI_TEST_CHECK(value);
878 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
880 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
881 DALI_TEST_CHECK(value);
882 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
884 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
885 DALI_TEST_CHECK(value);
886 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
888 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
889 DALI_TEST_CHECK(value);
890 DALI_TEST_CHECK(value->Get<bool>() == true);
895 int UtcDaliVisualGetPropertyMap6(void)
897 ToolkitTestApplication application;
898 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
900 Rect<int> border(1, 1, 1, 1);
902 VisualFactory factory = VisualFactory::Get();
903 Property::Map propertyMap;
904 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
905 propertyMap.Insert("mixColor", Color::MAGENTA);
906 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
907 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
908 propertyMap.Insert(ImageVisual::Property::BORDER, border);
909 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
910 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
911 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
913 Property::Map resultMap;
914 nPatchVisual.CreatePropertyMap(resultMap);
916 // check the property values from the returned map from visual
917 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
918 DALI_TEST_CHECK(value);
919 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
921 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
922 DALI_TEST_CHECK(value);
923 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
925 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
926 DALI_TEST_CHECK(value);
927 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
929 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
930 DALI_TEST_CHECK(value);
931 DALI_TEST_CHECK(value->Get<bool>());
933 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
934 DALI_TEST_CHECK(value);
935 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
937 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
938 DALI_TEST_CHECK(value);
939 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
941 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
942 DALI_TEST_CHECK(value);
943 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
945 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
947 Property::Map propertyMap1;
948 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
949 propertyMap1.Insert("mixColor", Color::MAGENTA);
950 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
951 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
952 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
953 nPatchVisual = factory.CreateVisual(propertyMap1);
955 nPatchVisual.CreatePropertyMap(resultMap);
957 // check the property values from the returned map from visual
958 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
959 DALI_TEST_CHECK(value);
960 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
962 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
963 DALI_TEST_CHECK(value);
964 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
966 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
967 DALI_TEST_CHECK(value);
968 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
970 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
971 DALI_TEST_CHECK(value);
972 DALI_TEST_CHECK(value->Get<bool>());
974 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
975 DALI_TEST_CHECK(value);
976 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
981 int UtcDaliVisualGetPropertyMap7(void)
983 ToolkitTestApplication application;
984 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
986 // request SvgVisual with a property map
987 VisualFactory factory = VisualFactory::Get();
988 Property::Map propertyMap;
989 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
990 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
991 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
992 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
993 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
995 Property::Map resultMap;
996 svgVisual.CreatePropertyMap(resultMap);
997 // check the property values from the returned map from a visual
998 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
999 DALI_TEST_CHECK(value);
1000 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1002 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1003 DALI_TEST_CHECK(value);
1004 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1006 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1007 DALI_TEST_CHECK(value);
1008 DALI_TEST_CHECK(value->Get<bool>() == false);
1010 // request SvgVisual with a property map 2
1011 propertyMap.Clear();
1012 propertyMap["visualType"] = Visual::SVG;
1013 propertyMap["mixColor"] = Color::WHITE;
1014 propertyMap["url"] = TEST_SVG_FILE_NAME;
1015 propertyMap["atlasing"] = true;
1016 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1019 svgVisual1.CreatePropertyMap(resultMap);
1020 // check the property values from the returned map from a visual
1021 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1022 DALI_TEST_CHECK(value);
1023 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1025 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1026 DALI_TEST_CHECK(value);
1027 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1029 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1030 DALI_TEST_CHECK(value);
1031 DALI_TEST_CHECK(value->Get<bool>() == true);
1033 // request SvgVisual with an URL
1034 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1036 svgVisual2.CreatePropertyMap(resultMap);
1037 // check the property values from the returned map from a visual
1038 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1039 DALI_TEST_CHECK(value);
1040 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1042 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1043 DALI_TEST_CHECK(value);
1044 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1050 int UtcDaliVisualGetPropertyMap8(void)
1052 ToolkitTestApplication application;
1053 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1055 //Request MeshVisual using a property map.
1056 VisualFactory factory = VisualFactory::Get();
1057 Property::Map propertyMap;
1058 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1059 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1060 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1061 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1062 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1063 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1064 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1065 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1067 Property::Map resultMap;
1068 meshVisual.CreatePropertyMap(resultMap);
1069 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1071 //Check values in the result map are identical to the initial map's values.
1072 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1073 DALI_TEST_CHECK(value);
1074 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1076 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1077 DALI_TEST_CHECK(value);
1078 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1080 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1081 DALI_TEST_CHECK(value);
1082 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1084 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1085 DALI_TEST_CHECK(value);
1086 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1088 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1089 DALI_TEST_CHECK(value);
1090 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1092 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1093 DALI_TEST_CHECK(value);
1094 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1099 //Primitive shape visual
1100 int UtcDaliVisualGetPropertyMap9(void)
1102 ToolkitTestApplication application;
1103 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1105 static std::vector<UniformData> customUniforms =
1107 UniformData("mixColor", Property::Type::VECTOR3),
1110 TestGraphicsController& graphics = application.GetGraphicsController();
1111 graphics.AddCustomUniforms(customUniforms);
1113 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1114 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1116 //Request PrimitiveVisual using a property map.
1117 VisualFactory factory = VisualFactory::Get();
1118 Property::Map propertyMap;
1119 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1120 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1121 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1122 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1123 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1124 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1125 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1126 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1127 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1128 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1129 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1130 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1131 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1132 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1134 Property::Map resultMap;
1135 primitiveVisual.CreatePropertyMap(resultMap);
1137 //Check values in the result map are identical to the initial map's values.
1138 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1139 DALI_TEST_CHECK(value);
1140 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1142 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1143 DALI_TEST_CHECK(value);
1144 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1146 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1147 DALI_TEST_CHECK(value);
1148 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1149 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1151 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1152 DALI_TEST_CHECK(value);
1153 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1155 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1156 DALI_TEST_CHECK(value);
1157 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1159 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1160 DALI_TEST_CHECK(value);
1161 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1163 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1164 DALI_TEST_CHECK(value);
1165 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1167 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1168 DALI_TEST_CHECK(value);
1169 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1171 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1172 DALI_TEST_CHECK(value);
1173 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1175 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1176 DALI_TEST_CHECK(value);
1177 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1179 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1180 DALI_TEST_CHECK(value);
1181 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1183 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1184 DALI_TEST_CHECK(value);
1185 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1187 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1188 DALI_TEST_CHECK(value);
1189 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1191 DummyControl actor = DummyControl::New(true);
1192 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1193 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1194 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1195 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1196 application.GetScene().Add(actor);
1198 Animation animation = Animation::New(1.0f);
1199 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1201 application.SendNotification();
1202 application.Render(0);
1203 application.Render(1000);
1204 application.SendNotification();
1206 auto& gl = application.GetGlAbstraction();
1207 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1209 tet_infoline("Check property map after animation");
1211 primitiveVisual.CreatePropertyMap(resultMap);
1212 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1213 DALI_TEST_CHECK(value);
1214 color = value->Get<Vector4>();
1215 // Ignore alpha part
1216 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1222 int UtcDaliVisualGetPropertyMap10(void)
1224 ToolkitTestApplication application;
1225 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1227 //Request PrimitiveVisual using a property map.
1228 VisualFactory factory = VisualFactory::Get();
1230 Property::Map propertyMap;
1231 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1232 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1233 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1234 propertyMap.Insert("enableMarkup", false);
1235 propertyMap.Insert("text", "Hello world");
1236 propertyMap.Insert("fontFamily", "TizenSans");
1238 Property::Map fontStyleMapSet;
1239 fontStyleMapSet.Insert("weight", "bold");
1240 propertyMap.Insert("fontStyle", fontStyleMapSet);
1242 propertyMap.Insert("pointSize", 12.f);
1243 propertyMap.Insert("multiLine", true);
1244 propertyMap.Insert("horizontalAlignment", "CENTER");
1245 propertyMap.Insert("verticalAlignment", "CENTER");
1246 propertyMap.Insert("textColor", Color::RED);
1248 Property::Map shadowMapSet;
1249 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1251 Property::Map underlineMapSet;
1252 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));
1254 Property::Map outlineMapSet;
1255 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1257 Property::Map backgroundMapSet;
1258 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1260 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1262 Property::Map resultMap;
1263 textVisual.CreatePropertyMap(resultMap);
1265 //Check values in the result map are identical to the initial map's values.
1266 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1267 DALI_TEST_CHECK(value);
1268 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1270 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1271 DALI_TEST_CHECK(value);
1272 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1274 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1275 DALI_TEST_CHECK(value);
1276 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1278 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1279 DALI_TEST_CHECK(value);
1280 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1282 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1283 DALI_TEST_CHECK(value);
1285 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1286 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1287 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1289 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1290 DALI_TEST_CHECK(value);
1291 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1293 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1294 DALI_TEST_CHECK(value);
1295 DALI_TEST_CHECK(value->Get<bool>());
1297 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1298 DALI_TEST_CHECK(value);
1299 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1301 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1302 DALI_TEST_CHECK(value);
1303 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1305 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1306 DALI_TEST_CHECK(value);
1307 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1309 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1310 DALI_TEST_CHECK(value);
1311 DALI_TEST_CHECK(!value->Get<bool>());
1313 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1314 DALI_TEST_CHECK(value);
1316 Property::Map shadowMapGet = value->Get<Property::Map>();
1317 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1318 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1320 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1321 DALI_TEST_CHECK(value);
1323 Property::Map underlineMapGet = value->Get<Property::Map>();
1324 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1325 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1327 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1328 DALI_TEST_CHECK(value);
1330 Property::Map outlineMapGet = value->Get<Property::Map>();
1331 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1332 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1334 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1335 DALI_TEST_CHECK(value);
1337 Property::Map backgroundMapGet = value->Get<Property::Map>();
1338 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1339 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1344 int UtcDaliVisualGetPropertyMap11(void)
1346 ToolkitTestApplication application;
1347 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1349 VisualFactory factory = VisualFactory::Get();
1350 DALI_TEST_CHECK(factory);
1352 Property::Map propertyMap;
1353 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1355 Vector2 start(-0.5f, 0.5f);
1356 Vector2 end(0.5f, -0.0f);
1357 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1358 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1359 Vector2 rotate_center(0.0f, 0.4f);
1360 float rotate_amount = 1.57f;
1361 float offset = 100.f;
1363 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1364 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1365 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1367 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1368 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1369 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1370 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1371 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1372 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1373 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1375 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1376 DALI_TEST_CHECK(animatedGradientVisual);
1378 Property::Map resultMap;
1379 animatedGradientVisual.CreatePropertyMap(resultMap);
1381 // check the property values from the returned map from visual
1382 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1383 DALI_TEST_CHECK(value);
1384 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1386 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1387 DALI_TEST_CHECK(value);
1388 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1390 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1391 DALI_TEST_CHECK(value);
1392 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1394 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1395 DALI_TEST_CHECK(value);
1396 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1398 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1399 DALI_TEST_CHECK(value);
1400 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1402 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1403 DALI_TEST_CHECK(value);
1404 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1406 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1407 DALI_TEST_CHECK(value);
1408 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1410 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1411 DALI_TEST_CHECK(value);
1412 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1414 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1415 DALI_TEST_CHECK(value);
1416 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1418 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1419 DALI_TEST_CHECK(value);
1420 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1422 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1423 DALI_TEST_CHECK(value);
1424 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1429 int UtcDaliVisualGetPropertyMap12(void)
1431 ToolkitTestApplication application;
1432 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1434 // Case 1 : Set values by index
1436 tet_printf(" - Set Values by Index\n");
1437 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1438 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1439 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1441 tet_printf("test with delay [%f]\n", _delay);
1442 VisualFactory factory = VisualFactory::Get();
1443 DALI_TEST_CHECK(factory);
1445 Property::Map propertyMap;
1446 Property::Map animationMap;
1447 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1449 float duration = 1.1f;
1450 float delay = _delay;
1451 float repeat_delay = 0.4f;
1453 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1455 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1456 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1458 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1459 animationMap.Clear();
1460 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1461 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1462 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1463 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1464 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1465 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1466 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1467 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1468 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1470 return animationMap;
1473 Vector2 start1(-0.5f, 0.5f);
1474 Vector2 end1(0.5f, -0.5f);
1475 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1476 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1477 Vector2 rotate_center1(0.0f, 0.4f);
1478 float rotate_amount1 = 0.0f;
1479 float offset1 = 0.f;
1481 Vector2 start2(-0.5f, -0.5f);
1482 Vector2 end2(0.5f, 0.5f);
1483 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1484 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1485 Vector2 rotate_center2(0.0f, -0.4f);
1486 float rotate_amount2 = 6.2832f;
1487 float offset2 = 2.f;
1489 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1490 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1491 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1493 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1494 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1495 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1496 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1497 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1498 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1499 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1501 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1502 DALI_TEST_CHECK(animatedGradientVisual);
1504 Property::Map resultMap;
1505 animatedGradientVisual.CreatePropertyMap(resultMap);
1507 // check the property values from the returned map from visual
1508 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1509 DALI_TEST_CHECK(value);
1510 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1512 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1513 DALI_TEST_CHECK(value);
1514 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1516 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1517 DALI_TEST_CHECK(value);
1518 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1520 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1521 DALI_TEST_CHECK(value);
1522 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1524 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 {
1525 tet_printf("Check value at %d\n", line_num);
1526 value = resultMap.Find(index, Property::MAP);
1527 DALI_TEST_CHECK(value);
1528 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1529 Property::Map* temp_map = value->GetMap();
1530 DALI_TEST_CHECK(temp_map);
1532 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1533 Property::Value* res = temp_map->Find(index);
1534 DALI_TEST_CHECK(res);
1538 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1539 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1540 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1541 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1542 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1543 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1544 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1545 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1546 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1549 // check the animation map data is good
1550 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1551 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1552 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1553 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1554 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1555 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1556 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1560 // Case 2 : Set values by string
1562 tet_printf(" - Set Values by String\n");
1563 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1564 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1565 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1567 tet_printf("test with delay [%f]\n", _delay);
1568 VisualFactory factory = VisualFactory::Get();
1569 DALI_TEST_CHECK(factory);
1571 Property::Map propertyMap;
1572 Property::Map animationMap;
1573 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1575 float duration = 1.1f;
1576 float delay = _delay;
1577 float repeat_delay = 0.4f;
1579 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1581 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1582 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1584 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1585 animationMap.Clear();
1586 animationMap.Insert("startValue", start);
1587 animationMap.Insert("targetValue", target);
1588 animationMap.Insert("directionType", "BACKWARD");
1589 animationMap.Insert("duration", duration);
1590 animationMap.Insert("delay", delay);
1591 animationMap.Insert("repeat", loop_count);
1592 animationMap.Insert("repeatDelay", repeat_delay);
1593 animationMap.Insert("motionType", "MIRROR");
1594 animationMap.Insert("easingType", "IN_OUT");
1596 return animationMap;
1599 Vector2 start1(-0.5f, 0.5f);
1600 Vector2 end1(0.5f, -0.5f);
1601 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1602 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1603 Vector2 rotate_center1(0.0f, 0.4f);
1604 float rotate_amount1 = 0.0f;
1605 float offset1 = 0.f;
1607 Vector2 start2(-0.5f, -0.5f);
1608 Vector2 end2(0.5f, 0.5f);
1609 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1610 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1611 Vector2 rotate_center2(0.0f, -0.4f);
1612 float rotate_amount2 = 6.2832f;
1613 float offset2 = 2.f;
1615 // For test mix the type string/index key and string/index value works well.
1616 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1617 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1618 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1620 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1621 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1622 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1623 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1624 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1625 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1626 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1628 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1629 DALI_TEST_CHECK(animatedGradientVisual);
1631 Property::Map resultMap;
1632 animatedGradientVisual.CreatePropertyMap(resultMap);
1634 // check the property values from the returned map from visual
1635 // Note : resultMap from CreatePropertyMap only contain indexKey
1636 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1637 DALI_TEST_CHECK(value);
1638 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1640 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1641 DALI_TEST_CHECK(value);
1642 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1644 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1645 DALI_TEST_CHECK(value);
1646 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1648 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1649 DALI_TEST_CHECK(value);
1650 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1652 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 {
1653 tet_printf("Check value at %d\n", line_num);
1654 value = resultMap.Find(index, Property::MAP);
1655 DALI_TEST_CHECK(value);
1656 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1657 Property::Map* temp_map = value->GetMap();
1658 DALI_TEST_CHECK(temp_map);
1660 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1661 Property::Value* res = temp_map->Find(index);
1662 DALI_TEST_CHECK(res);
1666 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1667 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1668 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1669 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1670 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1671 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1672 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1673 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1674 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1677 // check the animation map data is good
1678 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1679 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1680 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1681 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1682 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1683 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1684 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1690 int UtcDaliVisualGetPropertyMap13(void)
1692 ToolkitTestApplication application;
1693 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1695 for(int _direction = 0; _direction <= 1; ++_direction)
1697 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1699 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1700 VisualFactory factory = VisualFactory::Get();
1701 DALI_TEST_CHECK(factory);
1703 Property::Map propertyMap;
1704 Property::Map animationMap;
1705 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1707 float duration = 1.0f;
1708 float delay = _delay;
1709 float repeat_delay = 0.5f;
1711 int direction = _direction;
1712 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1713 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1714 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1716 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1717 animationMap.Clear();
1718 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1719 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1721 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1723 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1724 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1725 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1726 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1727 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1728 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1729 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1730 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1732 return animationMap;
1735 Vector2 start1(-0.5f, 0.5f);
1736 Vector2 end1(0.5f, -0.5f);
1737 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1738 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1739 Vector2 rotate_center1(1.0f, 0.4f);
1740 float rotate_amount1 = 2.0f;
1741 float offset1 = 1.f;
1743 Vector2 start2(-0.5f, -0.5f);
1744 Vector2 end2(0.5f, 0.5f);
1745 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1746 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1747 Vector2 rotate_center2(1.0f, -0.4f);
1748 float rotate_amount2 = 1.0f;
1749 float offset2 = 3.f;
1751 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1752 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1753 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1755 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1756 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1757 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1758 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1759 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1760 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1761 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1763 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1764 DALI_TEST_CHECK(animatedGradientVisual);
1766 Property::Map resultMap;
1767 animatedGradientVisual.CreatePropertyMap(resultMap);
1769 // check the property values from the returned map from visual
1770 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1771 DALI_TEST_CHECK(value);
1772 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1774 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1775 DALI_TEST_CHECK(value);
1776 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1778 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1779 DALI_TEST_CHECK(value);
1780 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1782 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1783 DALI_TEST_CHECK(value);
1784 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1786 // If loop_count = 0, Animation doesn't created.
1787 // Optimized resultMap only have one value, which is target value
1788 // Note: target value will be changed by direction option.
1789 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1790 DALI_TEST_CHECK(value);
1791 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1793 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1794 DALI_TEST_CHECK(value);
1795 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1797 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1798 DALI_TEST_CHECK(value);
1799 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1801 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1802 DALI_TEST_CHECK(value);
1803 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1805 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1806 DALI_TEST_CHECK(value);
1807 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1809 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1810 DALI_TEST_CHECK(value);
1811 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1813 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1814 DALI_TEST_CHECK(value);
1815 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1822 int UtcDaliVisualAnimateBorderVisual01(void)
1824 ToolkitTestApplication application;
1825 tet_infoline("UtcDaliAnimateBorderVisual Color");
1827 static std::vector<UniformData> customUniforms =
1829 UniformData("borderColor", Property::Type::VECTOR4),
1830 UniformData("mixColor", Property::Type::VECTOR3),
1833 TestGraphicsController& graphics = application.GetGraphicsController();
1834 graphics.AddCustomUniforms(customUniforms);
1836 VisualFactory factory = VisualFactory::Get();
1837 Property::Map propertyMap;
1838 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1839 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1840 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1841 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1842 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1845 map["target"] = "testVisual";
1846 map["property"] = "mixColor";
1847 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1848 map["animator"] = Property::Map()
1849 .Add("alphaFunction", "LINEAR")
1850 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1852 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1854 DummyControl actor = DummyControl::New(true);
1855 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1856 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1857 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1858 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1859 application.GetScene().Add(actor);
1861 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1863 Renderer renderer = actor.GetRendererAt(0);
1864 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1865 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1867 Animation animation = dummyImpl.CreateTransition(transition);
1869 // Animate the mix color through the transition, and the border color through
1870 // programmatic method.
1871 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1874 application.SendNotification();
1875 application.Render(0);
1876 application.Render(2000u); // halfway point between blue and white
1878 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1879 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1880 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1881 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1883 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1884 testColor = Vector4(1, 1, 1, 0.45f);
1885 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1886 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1889 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1890 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1892 application.Render(2000u);
1894 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1895 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1896 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1898 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1899 testColor = Vector4(1, 1, 1, 0.1);
1900 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1901 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1903 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1904 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1909 int UtcDaliVisualAnimateBorderVisual02(void)
1911 ToolkitTestApplication application;
1912 tet_infoline("UtcDaliAnimateBorderVisual Size");
1914 static std::vector<UniformData> customUniforms =
1916 UniformData("borderSize", Property::Type::FLOAT),
1919 TestGraphicsController& graphics = application.GetGraphicsController();
1920 graphics.AddCustomUniforms(customUniforms);
1922 VisualFactory factory = VisualFactory::Get();
1923 Property::Map propertyMap;
1924 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1925 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1926 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1927 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1929 DummyControl actor = DummyControl::New(true);
1930 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1931 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1932 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1933 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1934 application.GetScene().Add(actor);
1936 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1938 Renderer renderer = actor.GetRendererAt(0);
1939 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1941 Animation animation = Animation::New(4.0f);
1942 animation.AnimateTo(Property(renderer, index), 9.0f);
1945 application.SendNotification();
1946 application.Render(0);
1947 application.Render(2000u); // halfway point
1949 float size = renderer.GetCurrentProperty<float>(index);
1950 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1951 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1953 application.Render(2000u); // halfway point between blue and white
1955 size = renderer.GetCurrentProperty<float>(index);
1956 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1957 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1962 int UtcDaliVisualAnimateColorVisual(void)
1964 ToolkitTestApplication application;
1965 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1967 static std::vector<UniformData> customUniforms =
1969 UniformData("mixColor", Property::Type::VECTOR3),
1972 TestGraphicsController& graphics = application.GetGraphicsController();
1973 graphics.AddCustomUniforms(customUniforms);
1975 VisualFactory factory = VisualFactory::Get();
1976 Property::Map propertyMap;
1977 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1978 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1979 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1981 DummyControl actor = DummyControl::New(true);
1982 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1983 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1984 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1985 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1986 application.GetScene().Add(actor);
1988 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1990 Renderer renderer = actor.GetRendererAt(0);
1991 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1993 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1994 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1996 Animation animation = Animation::New(4.0f);
1997 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2000 application.SendNotification();
2001 application.Render(0);
2002 application.Render(2000u); // halfway point
2004 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2005 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2006 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2008 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2010 application.Render(2000u); // halfway point between blue and white
2012 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2013 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2015 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2017 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2018 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2023 int UtcDaliVisualAnimatePrimitiveVisual(void)
2025 ToolkitTestApplication application;
2026 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2028 static std::vector<UniformData> customUniforms =
2030 UniformData("mixColor", Property::Type::VECTOR3),
2033 TestGraphicsController& graphics = application.GetGraphicsController();
2034 graphics.AddCustomUniforms(customUniforms);
2037 VisualFactory factory = VisualFactory::Get();
2038 Property::Map propertyMap;
2039 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2040 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2041 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2042 Visual::Base visual = factory.CreateVisual(propertyMap);
2044 DummyControl actor = DummyControl::New(true);
2045 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2046 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2047 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2048 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2049 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2050 application.GetScene().Add(actor);
2052 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2054 Renderer renderer = actor.GetRendererAt(0);
2056 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2057 const Vector4 TARGET_MIX_COLOR(Color::RED);
2060 map["target"] = "testVisual";
2061 map["property"] = "mixColor";
2062 map["initialValue"] = INITIAL_MIX_COLOR;
2063 map["targetValue"] = TARGET_MIX_COLOR;
2064 map["animator"] = Property::Map()
2065 .Add("alphaFunction", "LINEAR")
2066 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2068 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2070 Animation animation = dummyImpl.CreateTransition(transition);
2071 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2074 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2075 glAbstraction.EnableEnableDisableCallTrace(true);
2076 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2077 std::ostringstream blendStr;
2078 blendStr << std::hex << GL_BLEND;
2080 application.SendNotification();
2081 application.Render(0);
2082 application.Render(2000u); // halfway point
2083 application.SendNotification();
2085 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2086 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2087 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2089 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2091 glEnableStack.Reset();
2093 application.Render(2001u); // go past end
2094 application.SendNotification(); // Trigger signals
2096 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2097 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2098 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2100 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2108 int UtcDaliVisualAnimatedGradientVisual01(void)
2110 ToolkitTestApplication application;
2111 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2113 static std::vector<UniformData> customUniforms =
2115 UniformData("start_point", Property::Type::VECTOR2),
2116 UniformData("end_point", Property::Type::VECTOR2),
2117 UniformData("start_color", Property::Type::VECTOR4),
2118 UniformData("end_color", Property::Type::VECTOR4),
2119 UniformData("rotate_center", Property::Type::VECTOR2),
2120 UniformData("rotate_angle", Property::Type::FLOAT),
2121 UniformData("gradient_offset", Property::Type::FLOAT),
2124 TestGraphicsController& graphics = application.GetGraphicsController();
2125 graphics.AddCustomUniforms(customUniforms);
2128 VisualFactory factory = VisualFactory::Get();
2129 Property::Map propertyMap;
2130 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2131 Visual::Base visual = factory.CreateVisual(propertyMap);
2133 DummyControl actor = DummyControl::New(true);
2134 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2135 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2136 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2137 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2138 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2139 application.GetScene().Add(actor);
2141 application.SendNotification();
2142 application.Render(0);
2143 application.SendNotification();
2145 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2147 for(int step_iter = 0; step_iter < 3; step_iter++)
2149 application.SendNotification();
2150 application.Render(0);
2151 application.Render(750u); // step i/4
2152 application.SendNotification();
2154 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2155 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2156 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2157 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2158 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2159 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2160 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2163 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2164 application.Render(750u); // go to end
2165 application.SendNotification();
2167 application.Render(10u); // finish
2168 application.SendNotification();
2171 application.SendNotification();
2172 application.Render(0u);
2173 application.SendNotification();
2179 int UtcDaliVisualAnimatedGradientVisual02(void)
2181 ToolkitTestApplication application;
2182 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2184 static std::vector<UniformData> customUniforms =
2186 UniformData("start_point", Property::Type::VECTOR2),
2187 UniformData("end_point", Property::Type::VECTOR2),
2188 UniformData("start_color", Property::Type::VECTOR4),
2189 UniformData("end_color", Property::Type::VECTOR4),
2190 UniformData("rotate_center", Property::Type::VECTOR2),
2191 UniformData("rotate_angle", Property::Type::FLOAT),
2192 UniformData("gradient_offset", Property::Type::FLOAT),
2195 TestGraphicsController& graphics = application.GetGraphicsController();
2196 graphics.AddCustomUniforms(customUniforms);
2199 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
2200 int _direction[2] = {0, 1};
2201 int _loop_count[3] = {-1, 0, 1};
2202 int _motion[2] = {0, 1};
2203 int _easing[4] = {0, 1, 2, 3};
2205 int test_case_max = 4 * 2 * 3 * 2 * 4;
2207 int test_case_d = 7; // 7 is the number of animated properties.
2209 float _duration = 0.4f;
2210 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2211 float noise_maker = 0.0f;
2212 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2213 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2215 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2217 VisualFactory factory = VisualFactory::Get();
2218 Property::Map propertyMap;
2219 Property::Map animationMap;
2220 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2222 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2223 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2224 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2226 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& {
2227 int tc = (test_case + tc_offset);
2228 int idx_easing = tc % 4;
2230 int idx_motion = tc % 2;
2232 int idx_loop_count = tc % 3;
2234 int idx_direction = tc % 2;
2236 int idx_delay = tc % 4;
2239 float duration = _duration - _repeat_delay;
2240 float repeat_delay = _repeat_delay;
2241 float delay = _delay[idx_delay] * _duration;
2242 int direction = _direction[idx_direction];
2243 int loop_count = _loop_count[idx_loop_count];
2244 int motion = _motion[idx_motion];
2245 int easing = _easing[idx_easing];
2247 animationMap.Clear();
2248 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2249 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2252 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2256 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2258 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2259 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2260 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2261 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2264 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2268 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2272 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2274 else if(easing == 1)
2276 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2278 else if(easing == 2)
2280 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2284 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2287 return animationMap;
2290 // Give different values for debuging
2291 noise_maker += 1.0f;
2292 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2293 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2294 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2295 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2296 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2297 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2298 float offset1 = 0.f + noise_maker * 0.1f;
2300 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2301 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2302 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2303 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2304 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2305 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2306 float offset2 = 2.f + noise_maker * 0.1f;
2308 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2309 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2310 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2312 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2313 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2314 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2315 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2316 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2317 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2318 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2320 Visual::Base visual = factory.CreateVisual(propertyMap);
2322 DummyControl actor = DummyControl::New(true);
2323 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2324 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2325 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2326 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2327 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2328 application.GetScene().Add(actor);
2330 application.SendNotification();
2331 application.Render(0);
2332 application.SendNotification();
2334 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2336 application.SendNotification();
2338 //Compare between CPU calculated value and Shader Visual calculated value
2339 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 {
2340 int tc = (test_case + tc_offset);
2341 int idx_easing = tc % 4;
2343 int idx_motion = tc % 2;
2345 int idx_loop_count = tc % 3;
2347 int idx_direction = tc % 2;
2349 int idx_delay = tc % 4;
2352 float duration = _duration - _repeat_delay;
2353 float repeat_delay = _repeat_delay;
2354 float delay = _delay[idx_delay] * _duration;
2355 int direction = _direction[idx_direction];
2356 int loop_count = _loop_count[idx_loop_count];
2357 int motion = _motion[idx_motion];
2358 int easing = _easing[idx_easing];
2360 progress -= delay / _duration;
2362 Property::Value s = start;
2363 Property::Value t = target;
2369 float x; ///< Animator progress value
2374 else if(loop_count > 0 && progress + 0.01f > loop_count)
2376 x = (motion == 0) ? 1.0f : 0.0f;
2384 progress = fmodf(progress, 1.0f);
2385 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2390 x = progress * 2.0f;
2397 if(easing == 1) // EASE_IN
2401 else if(easing == 2) // EASE_OUT
2403 x = 2.0f * x - x * x;
2405 else if(easing == 3) // EASE_IN_OUT
2407 x = x * x * (3.0f - 2.0f * x);
2410 if(value_type == 0) // result type is Float
2414 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2415 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2416 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2418 else if(value_type == 1) // result type is Vector2
2422 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2423 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2424 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2426 else if(value_type == 2) // result type is Vector3
2430 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2431 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2432 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2434 else // result type is Vector4
2438 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2439 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2440 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2445 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2447 for(int step_iter = 0; step_iter < 3; step_iter++)
2449 application.SendNotification();
2450 application.Render(_duration * 250.f); // step i/4
2451 application.SendNotification();
2454 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2455 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2456 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2457 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2458 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2459 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2460 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2462 application.SendNotification();
2463 application.Render(_duration * 250.f); // step 4/4 will not test
2464 application.SendNotification();
2468 application.SendNotification();
2470 application.SendNotification();
2471 application.Render(10.f); // tempral time
2472 application.SendNotification();
2479 int UtcDaliVisualAnimatedGradientVisual03(void)
2481 ToolkitTestApplication application;
2482 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2484 static std::vector<UniformData> customUniforms =
2486 UniformData("start_point", Property::Type::VECTOR2),
2487 UniformData("end_point", Property::Type::VECTOR2),
2488 UniformData("start_color", Property::Type::VECTOR4),
2489 UniformData("end_color", Property::Type::VECTOR4),
2490 UniformData("rotate_center", Property::Type::VECTOR2),
2491 UniformData("rotate_angle", Property::Type::FLOAT),
2492 UniformData("gradient_offset", Property::Type::FLOAT),
2495 TestGraphicsController& graphics = application.GetGraphicsController();
2496 graphics.AddCustomUniforms(customUniforms);
2499 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
2500 int _direction[2] = {0, 1};
2501 int _loop_count[3] = {-1, 0, 1};
2502 int _motion[2] = {0, 1};
2503 int _easing[4] = {0, 1, 2, 3};
2505 int test_case_max = 4 * 2 * 3 * 2 * 4;
2507 int test_case_d = 7; // 7 is the number of animated properties.
2509 float _duration = 0.4f;
2510 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2511 float noise_maker = 0.2f;
2512 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2513 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2515 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2517 VisualFactory factory = VisualFactory::Get();
2518 Property::Map propertyMap;
2519 Property::Map animationMap;
2520 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2522 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& {
2523 int tc = (test_case + tc_offset);
2524 int idx_easing = tc % 4;
2526 int idx_motion = tc % 2;
2528 int idx_loop_count = tc % 3;
2530 int idx_direction = tc % 2;
2532 int idx_delay = tc % 4;
2535 float duration = _duration - _repeat_delay;
2536 float repeat_delay = _repeat_delay;
2537 float delay = _delay[idx_delay] * _duration;
2538 int direction = _direction[idx_direction];
2539 int loop_count = _loop_count[idx_loop_count];
2540 int motion = _motion[idx_motion];
2541 int easing = _easing[idx_easing];
2543 animationMap.Clear();
2544 animationMap.Insert("startValue", start);
2545 animationMap.Insert("targetValue", target);
2548 animationMap.Insert("directionType", "FORWARD");
2552 animationMap.Insert("directionType", "BACKWARD");
2554 animationMap.Insert("duration", duration);
2555 animationMap.Insert("delay", delay);
2556 animationMap.Insert("repeat", loop_count);
2557 animationMap.Insert("repeatDelay", repeat_delay);
2560 animationMap.Insert("motionType", "LOOP");
2564 animationMap.Insert("motionType", "MIRROR");
2568 animationMap.Insert("easingType", "LINEAR");
2570 else if(easing == 1)
2572 animationMap.Insert("easingType", "IN");
2574 else if(easing == 2)
2576 animationMap.Insert("easingType", "OUT");
2580 animationMap.Insert("easingType", "IN_OUT");
2583 return animationMap;
2586 // Give different values for debuging
2587 noise_maker += 0.8f;
2588 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2589 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2590 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2591 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2592 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2593 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2594 float offset1 = 0.f + noise_maker * 0.1f;
2596 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2597 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2598 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2599 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2600 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2601 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2602 float offset2 = 2.f + noise_maker * 0.1f;
2604 propertyMap.Insert("gradientType", "LINEAR");
2605 propertyMap.Insert("unitType", "USER_SPACE");
2606 propertyMap.Insert("spreadType", "CLAMP");
2608 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2609 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2610 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2611 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2612 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2613 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2614 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2616 Visual::Base visual = factory.CreateVisual(propertyMap);
2618 DummyControl actor = DummyControl::New(true);
2619 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2620 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2621 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2622 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2623 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2624 application.GetScene().Add(actor);
2626 application.SendNotification();
2627 application.Render(0);
2628 application.SendNotification();
2630 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2632 application.SendNotification();
2634 //Compare between CPU calculated value and Shader Visual calculated value
2635 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 {
2636 int tc = (test_case + tc_offset);
2637 int idx_easing = tc % 4;
2639 int idx_motion = tc % 2;
2641 int idx_loop_count = tc % 3;
2643 int idx_direction = tc % 2;
2645 int idx_delay = tc % 4;
2648 float duration = _duration - _repeat_delay;
2649 float repeat_delay = _repeat_delay;
2650 float delay = _delay[idx_delay] * _duration;
2651 int direction = _direction[idx_direction];
2652 int loop_count = _loop_count[idx_loop_count];
2653 int motion = _motion[idx_motion];
2654 int easing = _easing[idx_easing];
2656 progress -= delay / _duration;
2658 Property::Value s = start;
2659 Property::Value t = target;
2665 float x; ///< Animator progress value
2670 else if(loop_count > 0 && progress + 0.01f > loop_count)
2672 x = (motion == 0) ? 1.0f : 0.0f;
2680 progress = fmodf(progress, 1.0f);
2681 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2686 x = progress * 2.0f;
2693 if(easing == 1) // EASE_IN
2697 else if(easing == 2) // EASE_OUT
2699 x = 2.0f * x - x * x;
2701 else if(easing == 3) // EASE_IN_OUT
2703 x = x * x * (3.0f - 2.0f * x);
2706 if(value_type == 0) // result type is Float
2710 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2711 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2712 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2714 else if(value_type == 1) // result type is Vector2
2718 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2719 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2720 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2722 else if(value_type == 2) // result type is Vector3
2726 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2727 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2728 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2730 else // result type is Vector4
2734 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2735 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2736 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2741 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2743 for(int step_iter = 0; step_iter < 3; step_iter++)
2745 application.SendNotification();
2746 application.Render(_duration * 250.f); // step i/4
2747 application.SendNotification();
2750 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2751 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2752 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2753 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2754 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2755 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2756 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2758 application.SendNotification();
2759 application.Render(_duration * 250.f); // step 4/4 will not test
2760 application.SendNotification();
2764 application.SendNotification();
2766 application.SendNotification();
2767 application.Render(10.f); // tempral time
2768 application.SendNotification();
2775 int UtcDaliVisualWireframeVisual(void)
2777 ToolkitTestApplication application;
2779 VisualFactory factory = VisualFactory::Get();
2780 Property::Map propertyMap;
2781 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2783 // Create the visual.
2784 Visual::Base visual = factory.CreateVisual(propertyMap);
2786 DALI_TEST_CHECK(visual);
2788 Property::Map resultMap;
2789 visual.CreatePropertyMap(resultMap);
2791 // Check the property values from the returned map from visual
2792 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2793 DALI_TEST_CHECK(value);
2794 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2799 int UtcDaliVisualGetTransform(void)
2801 ToolkitTestApplication application;
2802 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2804 VisualFactory factory = VisualFactory::Get();
2805 Property::Map propertyMap;
2806 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2807 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2808 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2810 Dali::Property::Map visualMap;
2811 colorVisual.CreatePropertyMap(visualMap);
2812 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2813 Dali::Property::Map* map = value->GetMap();
2814 DALI_TEST_CHECK(map);
2816 //Test default values
2818 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2819 DALI_TEST_CHECK(typeValue);
2820 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2823 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2824 DALI_TEST_CHECK(typeValue);
2825 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2828 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2829 DALI_TEST_CHECK(typeValue);
2830 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2833 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2834 DALI_TEST_CHECK(typeValue);
2835 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2838 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2839 DALI_TEST_CHECK(typeValue);
2840 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2843 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2844 DALI_TEST_CHECK(typeValue);
2845 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2848 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2849 DALI_TEST_CHECK(typeValue);
2850 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2856 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2858 Property::Map transform;
2859 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2860 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2861 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2862 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2863 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2864 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2866 visual.SetTransformAndSize(transform, Vector2(100, 100));
2868 Dali::Property::Map visualMap;
2869 visual.CreatePropertyMap(visualMap);
2870 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2871 Dali::Property::Map* map = value->GetMap();
2872 DALI_TEST_CHECK(map);
2875 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2876 DALI_TEST_CHECK(typeValue);
2877 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2880 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2881 DALI_TEST_CHECK(typeValue);
2882 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2885 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2886 DALI_TEST_CHECK(typeValue);
2887 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2890 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2891 DALI_TEST_CHECK(typeValue);
2892 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2895 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2896 DALI_TEST_CHECK(typeValue);
2897 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2900 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2901 DALI_TEST_CHECK(typeValue);
2902 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2905 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2906 DALI_TEST_CHECK(typeValue);
2907 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2910 //Put the visual on the stage
2911 DummyControl actor = DummyControl::New(true);
2912 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2913 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2914 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2915 application.GetScene().Add(actor);
2917 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2918 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2920 application.SendNotification();
2921 application.Render(0);
2922 Renderer renderer(actor.GetRendererAt(0));
2924 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2925 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2927 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2928 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2930 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2931 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2933 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2934 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2936 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2937 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2939 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2940 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2942 //Set a new transform
2944 transform = DefaultTransform();
2945 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2946 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2947 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2948 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2949 visual.SetTransformAndSize(transform, Vector2(100, 100));
2950 application.SendNotification();
2951 application.Render(0);
2953 //Check that the values have changed in the renderer
2954 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2955 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2957 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2958 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2960 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2961 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2963 //Parent origin and anchor point should have the default values
2964 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2965 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2967 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2968 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2970 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2971 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2974 int UtcDaliVisualSetTransform01(void)
2976 ToolkitTestApplication application;
2977 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2979 VisualFactory factory = VisualFactory::Get();
2980 Property::Map propertyMap;
2981 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2982 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2983 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2984 Visual::Base visual = factory.CreateVisual(propertyMap);
2985 TestTransform(application, visual);
2986 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2991 int UtcDaliVisualSetTransform0(void)
2993 ToolkitTestApplication application;
2994 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2996 VisualFactory factory = VisualFactory::Get();
2997 Property::Map propertyMap;
2998 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2999 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3000 Visual::Base visual = factory.CreateVisual(propertyMap);
3001 TestTransform(application, visual);
3002 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3007 int UtcDaliVisualSetTransform1(void)
3009 ToolkitTestApplication application;
3010 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3012 VisualFactory factory = VisualFactory::Get();
3013 Property::Map propertyMap;
3014 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3015 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3016 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3017 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3018 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3019 Visual::Base visual = factory.CreateVisual(propertyMap);
3020 TestTransform(application, visual);
3021 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3026 int UtcDaliVisualSetTransform2(void)
3028 ToolkitTestApplication application;
3029 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3031 VisualFactory factory = VisualFactory::Get();
3032 Property::Map propertyMap;
3033 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3034 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3036 Property::Array stopOffsets;
3037 stopOffsets.PushBack(0.0f);
3038 stopOffsets.PushBack(0.3f);
3039 stopOffsets.PushBack(0.6f);
3040 stopOffsets.PushBack(0.8f);
3041 stopOffsets.PushBack(1.0f);
3042 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3044 Property::Array stopColors;
3045 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3046 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3047 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3048 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3049 stopColors.PushBack(Color::YELLOW);
3050 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3051 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3052 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3053 Visual::Base visual = factory.CreateVisual(propertyMap);
3054 TestTransform(application, visual);
3055 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3060 int UtcDaliVisualSetTransform3(void)
3062 ToolkitTestApplication application;
3063 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3065 VisualFactory factory = VisualFactory::Get();
3066 Property::Map propertyMap;
3067 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3068 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3069 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3070 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3071 Visual::Base visual = factory.CreateVisual(propertyMap);
3072 TestTransform(application, visual);
3073 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3078 int UtcDaliVisualSetTransform4(void)
3080 ToolkitTestApplication application;
3081 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3083 VisualFactory factory = VisualFactory::Get();
3084 Property::Map propertyMap;
3085 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3086 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3088 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3089 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3090 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3091 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3092 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3093 Visual::Base visual = factory.CreateVisual(propertyMap);
3094 TestTransform(application, visual);
3095 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3100 int UtcDaliVisualSetTransform5(void)
3102 ToolkitTestApplication application;
3103 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3105 VisualFactory factory = VisualFactory::Get();
3106 Property::Map propertyMap;
3107 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3108 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3109 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3110 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3111 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3112 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3113 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3114 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3115 Visual::Base visual = factory.CreateVisual(propertyMap);
3116 TestTransform(application, visual);
3117 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3122 int UtcDaliVisualSetTransform6(void)
3124 ToolkitTestApplication application;
3125 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3127 VisualFactory factory = VisualFactory::Get();
3128 Property::Map propertyMap;
3129 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3130 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3131 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3132 Visual::Base visual = factory.CreateVisual(propertyMap);
3133 TestTransform(application, visual);
3134 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3139 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3141 ToolkitTestApplication application;
3142 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3144 VisualFactory factory = VisualFactory::Get();
3145 Property::Map propertyMap;
3146 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3147 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3148 Visual::Base visual = factory.CreateVisual(propertyMap);
3150 Property::Map transform;
3151 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3152 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3153 visual.SetTransformAndSize(transform, Vector2(100, 100));
3155 Dali::Property::Map visualMap;
3156 visual.CreatePropertyMap(visualMap);
3157 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3158 Dali::Property::Map* map = value->GetMap();
3159 DALI_TEST_CHECK(map);
3162 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3163 DALI_TEST_CHECK(typeValue);
3164 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3167 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3168 DALI_TEST_CHECK(typeValue);
3169 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3175 int UtcDaliNPatchVisualCustomShader(void)
3177 ToolkitTestApplication application;
3178 tet_infoline("NPatchVisual with custom shader");
3180 VisualFactory factory = VisualFactory::Get();
3181 Property::Map properties;
3182 Property::Map shader;
3183 const std::string vertexShader = "Foobar";
3184 const std::string fragmentShader = "Foobar";
3185 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3186 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3188 Property::Map transformMap;
3189 transformMap["size"] = Vector2(0.5f, 0.5f);
3190 transformMap["offset"] = Vector2(20.0f, 0.0f);
3191 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3192 transformMap["anchorPoint"] = Align::CENTER;
3193 transformMap["origin"] = Align::CENTER;
3194 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3195 properties[Visual::Property::TRANSFORM] = transformMap;
3197 properties[Visual::Property::TYPE] = Visual::IMAGE;
3198 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3199 properties[Visual::Property::SHADER] = shader;
3200 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3201 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3203 Visual::Base visual = factory.CreateVisual(properties);
3204 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3206 // trigger creation through setting on stage
3207 DummyControl dummy = DummyControl::New(true);
3208 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3209 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3210 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3211 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3212 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3213 application.GetScene().Add(dummy);
3214 application.SendNotification();
3216 Renderer renderer = dummy.GetRendererAt(0);
3217 Shader shader2 = renderer.GetShader();
3218 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3219 Property::Map* map = value.GetMap();
3220 DALI_TEST_CHECK(map);
3222 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3223 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3225 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3226 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3228 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3229 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3231 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3232 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3237 int UtcDaliGradientVisualBlendMode(void)
3239 ToolkitTestApplication application;
3240 VisualFactory factory = VisualFactory::Get();
3242 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3243 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)));
3245 Visual::Base alphaGradientVisual = factory.CreateVisual(
3246 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))));
3248 DummyControl control = DummyControl::New(true);
3249 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3250 application.GetScene().Add(control);
3252 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3253 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3254 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3256 application.SendNotification();
3257 application.Render();
3259 // 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
3260 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3261 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3262 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3267 int UtcDaliVisualRendererRemovalAndReAddition(void)
3269 ToolkitTestApplication application;
3270 tet_infoline("UtcDaliVisualRendererRemoval");
3272 VisualFactory factory = VisualFactory::Get();
3273 Property::Map propertyMap;
3274 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3275 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3276 Visual::Base visual = factory.CreateVisual(propertyMap);
3278 visual.SetDepthIndex(1);
3280 DummyControl dummyControl = DummyControl::New(true);
3281 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3282 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3283 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3285 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3286 tet_infoline("Add control with visual to stage and check renderer count is 1");
3288 application.GetScene().Add(dummyControl);
3290 application.SendNotification();
3291 application.Render();
3293 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3295 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3296 application.GetScene().Remove(dummyControl);
3297 application.SendNotification();
3298 application.Render();
3300 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3302 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3304 application.GetScene().Add(dummyControl);
3306 application.SendNotification();
3307 application.Render();
3309 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3314 int UtcDaliVisualTextVisualRender(void)
3316 ToolkitTestApplication application;
3317 tet_infoline("UtcDaliVisualTextVisualRender");
3319 VisualFactory factory = VisualFactory::Get();
3320 Property::Map propertyMap;
3321 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3322 propertyMap.Insert("mixColor", Color::WHITE);
3323 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3324 propertyMap.Insert("enableMarkup", false);
3325 propertyMap.Insert("text", "Hello world");
3326 propertyMap.Insert("fontFamily", "TizenSans");
3328 Property::Map fontStyleMapSet;
3329 fontStyleMapSet.Insert("weight", "bold");
3330 propertyMap.Insert("fontStyle", fontStyleMapSet);
3332 propertyMap.Insert("pointSize", 12.f);
3333 propertyMap.Insert("multiLine", true);
3334 propertyMap.Insert("horizontalAlignment", "CENTER");
3335 propertyMap.Insert("verticalAlignment", "CENTER");
3336 propertyMap.Insert("textColor", Color::RED);
3337 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3338 textVisual.SetDepthIndex(1);
3340 DummyControl dummyControl = DummyControl::New(true);
3341 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3342 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3343 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3345 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3346 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3348 application.GetScene().Add(dummyControl);
3349 application.SendNotification();
3350 application.Render();
3352 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3353 propertyMap.Clear();
3354 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3355 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3356 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3357 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3359 Property::Map transformMap;
3360 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3361 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3363 textVisual = factory.CreateVisual(propertyMap);
3364 textVisual.SetDepthIndex(1);
3366 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3367 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3369 application.SendNotification(); // force process events to ensure text visual
3370 // adds renderer to the dummy control in OnRelayout
3371 application.Render();
3373 Renderer renderer = dummyControl.GetRendererAt(0u);
3374 Property::Index index = renderer.GetPropertyIndex("transformSize");
3376 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3377 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3382 int UtcDaliVisualTextVisualDisableEnable(void)
3384 ToolkitTestApplication application;
3385 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3387 VisualFactory factory = VisualFactory::Get();
3388 Property::Map propertyMap;
3389 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3390 propertyMap.Insert("mixColor", Color::WHITE);
3391 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3392 propertyMap.Insert("enableMarkup", false);
3393 propertyMap.Insert("text", "Hello world");
3394 propertyMap.Insert("fontFamily", "TizenSans");
3396 Property::Map fontStyleMapSet;
3397 fontStyleMapSet.Insert("weight", "bold");
3398 propertyMap.Insert("fontStyle", fontStyleMapSet);
3400 propertyMap.Insert("pointSize", 12.f);
3401 propertyMap.Insert("multiLine", true);
3402 propertyMap.Insert("horizontalAlignment", "CENTER");
3403 propertyMap.Insert("verticalAlignment", "CENTER");
3404 propertyMap.Insert("textColor", Color::RED);
3405 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3406 textVisual.SetDepthIndex(1);
3408 DummyControl dummyControl = DummyControl::New(true);
3409 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3410 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3411 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3413 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3414 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3416 application.GetScene().Add(dummyControl);
3417 application.SendNotification();
3418 application.Render();
3420 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3422 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3424 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3426 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3428 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3433 int UtcDaliVisualPremultipliedAlpha(void)
3435 ToolkitTestApplication application;
3436 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3438 VisualFactory factory = VisualFactory::Get();
3440 // image visual, test default value ( true )
3442 Visual::Base imageVisual = factory.CreateVisual(
3444 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3445 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3447 Dali::Property::Map visualMap;
3448 imageVisual.CreatePropertyMap(visualMap);
3449 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3452 DALI_TEST_CHECK(value);
3453 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3456 // image visual, override premultiplied
3458 Visual::Base imageVisual = factory.CreateVisual(
3460 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3461 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3462 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3464 Dali::Property::Map visualMap;
3465 imageVisual.CreatePropertyMap(visualMap);
3466 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3469 DALI_TEST_CHECK(value);
3470 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3473 // svg visual ( premultiplied alpha by default is true )
3475 Visual::Base imageVisual = factory.CreateVisual(
3477 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3478 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3480 Dali::Property::Map visualMap;
3481 imageVisual.CreatePropertyMap(visualMap);
3482 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3485 DALI_TEST_CHECK(value);
3486 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3492 int UtcDaliRegisterVisualOrder(void)
3494 ToolkitTestApplication application;
3495 tet_infoline("Register Visual Order");
3497 DummyControl dummyControl = DummyControl::New(true);
3498 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3500 VisualFactory factory = VisualFactory::Get();
3501 Property::Map propertyMap;
3502 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3503 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3505 tet_infoline("Register visual, should have depth index of 0.0f");
3506 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3507 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3508 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3510 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3512 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3513 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3514 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3516 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3517 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3518 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3520 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3521 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3522 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3524 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3525 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3526 labelVisual.SetDepthIndex(-2000);
3527 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3528 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3530 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3531 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3532 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3533 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3534 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3535 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3537 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3538 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3539 anotherTestVisual2Replacement.SetDepthIndex(2000);
3540 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3541 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3543 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3544 application.GetScene().Add(dummyControl);
3549 int UtcDaliRegisterVisualOrder02(void)
3551 ToolkitTestApplication application;
3552 tet_infoline("Register Visual Order with Background Set");
3554 DummyControl dummyControl = DummyControl::New(true);
3555 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3557 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3559 VisualFactory factory = VisualFactory::Get();
3560 Property::Map propertyMap;
3561 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3562 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3564 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3566 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3568 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3569 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3570 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3571 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3572 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3574 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3575 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3576 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3577 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3579 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3580 application.GetScene().Add(dummyControl);
3585 int UtcDaliRegisterVisualWithDepthIndex(void)
3587 ToolkitTestApplication application;
3588 tet_infoline("Register a Visual With Depth Index");
3590 DummyControl dummyControl = DummyControl::New(true);
3591 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3593 VisualFactory factory = VisualFactory::Get();
3594 Property::Map propertyMap;
3595 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3596 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3598 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3599 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3600 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3601 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3602 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3604 tet_infoline("Register another visual with a depth index and it disabled");
3605 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3606 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3607 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3608 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3610 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3611 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3612 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3613 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3614 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3616 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3617 application.GetScene().Add(dummyControl);
3622 int UtcDaliSvgVisualCustomShader(void)
3624 ToolkitTestApplication application;
3625 tet_infoline("SvgVisual with custom shader");
3627 VisualFactory factory = VisualFactory::Get();
3628 Property::Map properties;
3629 Property::Map shader;
3630 const std::string vertexShader = "Foobar";
3631 const std::string fragmentShader = "Foobar";
3632 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3633 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3635 properties[Visual::Property::TYPE] = Visual::IMAGE;
3636 properties[Visual::Property::SHADER] = shader;
3637 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3639 Visual::Base visual = factory.CreateVisual(properties);
3641 // trigger creation through setting on stage
3642 DummyControl dummy = DummyControl::New(true);
3643 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3644 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3646 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3647 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3648 application.GetScene().Add(dummy);
3650 application.SendNotification();
3651 application.Render();
3653 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3655 Renderer renderer = dummy.GetRendererAt(0);
3656 Shader shader2 = renderer.GetShader();
3657 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3658 Property::Map* map = value.GetMap();
3659 DALI_TEST_CHECK(map);
3661 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3662 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3664 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3665 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3670 int UtcDaliVisualRoundedCorner(void)
3672 ToolkitTestApplication application;
3673 tet_infoline("UtcDaliVisualRoundedCorner");
3675 static std::vector<UniformData> customUniforms =
3677 UniformData("cornerRadius", Property::Type::VECTOR4),
3678 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3681 TestGraphicsController& graphics = application.GetGraphicsController();
3682 graphics.AddCustomUniforms(customUniforms);
3686 VisualFactory factory = VisualFactory::Get();
3687 Property::Map properties;
3688 float cornerRadius = 30.0f;
3690 properties[Visual::Property::TYPE] = Visual::IMAGE;
3691 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3692 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3694 Visual::Base visual = factory.CreateVisual(properties);
3696 // trigger creation through setting on stage
3697 DummyControl dummy = DummyControl::New(true);
3698 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3699 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3701 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3702 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3703 application.GetScene().Add(dummy);
3705 application.SendNotification();
3706 application.Render();
3708 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3710 application.SendNotification();
3711 application.Render();
3713 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3714 // Default corner radius policy is absolute.
3715 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3720 VisualFactory factory = VisualFactory::Get();
3721 Property::Map properties;
3722 float cornerRadius = 30.0f;
3724 properties[Visual::Property::TYPE] = Visual::COLOR;
3725 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3726 properties["cornerRadius"] = cornerRadius;
3727 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3729 Visual::Base visual = factory.CreateVisual(properties);
3731 // trigger creation through setting on stage
3732 DummyControl dummy = DummyControl::New(true);
3733 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3734 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3736 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3737 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3738 application.GetScene().Add(dummy);
3740 application.SendNotification();
3741 application.Render();
3743 application.SendNotification();
3744 application.Render();
3746 // Currently test with multiple program doesn't work well. will fix another day
3747 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3748 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3753 VisualFactory factory = VisualFactory::Get();
3754 Property::Map properties;
3755 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3757 properties[Visual::Property::TYPE] = Visual::COLOR;
3758 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3759 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3760 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3762 Visual::Base visual = factory.CreateVisual(properties);
3764 // trigger creation through setting on stage
3765 DummyControl dummy = DummyControl::New(true);
3766 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3767 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3769 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3770 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3771 application.GetScene().Add(dummy);
3773 application.SendNotification();
3774 application.Render();
3776 application.SendNotification();
3777 application.Render();
3779 // Currently test with multiple program doesn't work well. will fix another day
3780 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3781 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3784 // color visual 3 - invalid value
3786 VisualFactory factory = VisualFactory::Get();
3787 Property::Map properties;
3788 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3790 properties[Visual::Property::TYPE] = Visual::COLOR;
3791 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3792 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3793 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3795 Visual::Base visual = factory.CreateVisual(properties);
3797 // trigger creation through setting on stage
3798 DummyControl dummy = DummyControl::New(true);
3799 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3800 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3802 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3803 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3804 application.GetScene().Add(dummy);
3806 application.SendNotification();
3807 application.Render();
3809 application.SendNotification();
3810 application.Render();
3812 // Currently test with multiple program doesn't work well. will fix another day
3813 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3814 // Default corner radius policy is absolute.
3815 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3820 VisualFactory factory = VisualFactory::Get();
3821 Property::Map properties;
3822 float cornerRadius = 30.0f;
3824 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3825 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3826 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3827 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3828 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3829 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3831 Property::Array stopOffsets;
3832 stopOffsets.PushBack(0.0f);
3833 stopOffsets.PushBack(0.6f);
3834 stopOffsets.PushBack(1.0f);
3835 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3837 Property::Array stopColors;
3838 stopColors.PushBack(Color::RED);
3839 stopColors.PushBack(Color::YELLOW);
3840 stopColors.PushBack(Color::GREEN);
3841 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3843 Visual::Base visual = factory.CreateVisual(properties);
3845 // trigger creation through setting on stage
3846 DummyControl dummy = DummyControl::New(true);
3847 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3848 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3850 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3851 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3852 application.GetScene().Add(dummy);
3854 application.SendNotification();
3855 application.Render();
3857 application.SendNotification();
3858 application.Render();
3860 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3861 // Default corner radius policy is absolute.
3862 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3865 // animated image visual
3867 VisualFactory factory = VisualFactory::Get();
3868 Property::Map properties;
3869 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3871 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3872 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3873 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
3874 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3875 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3877 Visual::Base visual = factory.CreateVisual(properties);
3879 // trigger creation through setting on stage
3880 DummyControl dummy = DummyControl::New(true);
3881 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3882 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3884 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3885 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3886 application.GetScene().Add(dummy);
3888 application.SendNotification();
3889 application.Render();
3891 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3893 application.SendNotification();
3894 application.Render();
3896 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3897 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3900 // vector image visual
3902 VisualFactory factory = VisualFactory::Get();
3903 Property::Map properties;
3904 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
3906 properties[Visual::Property::TYPE] = Visual::SVG;
3907 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3908 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3910 Visual::Base visual = factory.CreateVisual(properties);
3912 // trigger creation through setting on stage
3913 DummyControl dummy = DummyControl::New(true);
3914 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3915 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3917 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3918 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3919 application.GetScene().Add(dummy);
3921 application.SendNotification();
3922 application.Render();
3924 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3926 application.SendNotification();
3927 application.Render();
3929 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3930 // Default corner radius policy is absolute.
3931 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3934 // animated vector image visual
3936 VisualFactory factory = VisualFactory::Get();
3937 Property::Map properties;
3938 float cornerRadius = 1.3f;
3940 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
3941 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
3942 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
3943 properties["cornerRadius"] = cornerRadius;
3944 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3946 Visual::Base visual = factory.CreateVisual(properties);
3948 // trigger creation through setting on stage
3949 DummyControl dummy = DummyControl::New(true);
3950 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3951 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3953 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3954 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3955 application.GetScene().Add(dummy);
3957 application.SendNotification();
3958 application.Render();
3960 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3962 application.SendNotification();
3963 application.Render();
3965 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3966 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3972 int UtcDaliVisualBorderline(void)
3974 ToolkitTestApplication application;
3975 tet_infoline("UtcDaliVisualBorderline");
3977 static std::vector<UniformData> customUniforms =
3979 UniformData("cornerRadius", Property::Type::VECTOR4),
3980 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3981 UniformData("borderlineWidth", Property::Type::FLOAT),
3982 UniformData("borderlineColor", Property::Type::VECTOR4),
3983 UniformData("borderlineOffset", Property::Type::FLOAT),
3986 TestGraphicsController& graphics = application.GetGraphicsController();
3987 graphics.AddCustomUniforms(customUniforms);
3991 VisualFactory factory = VisualFactory::Get();
3992 Property::Map properties;
3993 float cornerRadius = 5.0f;
3994 float borderlineWidth = 30.0f;
3995 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
3996 float borderlineOffset = 1.0f;
3998 properties[Visual::Property::TYPE] = Visual::IMAGE;
3999 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4000 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4001 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4002 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4003 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4005 Visual::Base visual = factory.CreateVisual(properties);
4007 // trigger creation through setting on stage
4008 DummyControl dummy = DummyControl::New(true);
4009 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4010 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4012 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4013 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4014 application.GetScene().Add(dummy);
4016 application.SendNotification();
4017 application.Render();
4019 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4021 application.SendNotification();
4022 application.Render();
4024 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4025 // Default corner radius policy is absolute.
4026 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4027 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4028 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4029 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4034 VisualFactory factory = VisualFactory::Get();
4035 Property::Map properties;
4036 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4037 float borderlineWidth = 30.0f;
4038 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4039 float borderlineOffset = -0.4f;
4041 properties[Visual::Property::TYPE] = Visual::COLOR;
4042 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4043 properties["cornerRadius"] = cornerRadius;
4044 properties["borderlineWidth"] = borderlineWidth;
4045 properties["borderlineColor"] = borderlineColor;
4046 properties["borderlineOffset"] = borderlineOffset;
4048 Visual::Base visual = factory.CreateVisual(properties);
4050 // trigger creation through setting on stage
4051 DummyControl dummy = DummyControl::New(true);
4052 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4053 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4055 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4056 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4057 application.GetScene().Add(dummy);
4059 application.SendNotification();
4060 application.Render();
4062 application.SendNotification();
4063 application.Render();
4065 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4066 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4067 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4068 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4071 // color visual 2, default color, default offset
4073 VisualFactory factory = VisualFactory::Get();
4074 Property::Map properties;
4075 float borderlineWidth = 30.0f;
4077 properties[Visual::Property::TYPE] = Visual::COLOR;
4078 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4079 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4081 Visual::Base visual = factory.CreateVisual(properties);
4083 // trigger creation through setting on stage
4084 DummyControl dummy = DummyControl::New(true);
4085 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4086 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4088 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4089 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4090 application.GetScene().Add(dummy);
4092 application.SendNotification();
4093 application.Render();
4095 application.SendNotification();
4096 application.Render();
4098 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4099 // Default borderline color is BLACK.
4100 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4101 // Default borderline offset is 0.0f.
4102 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4105 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4107 VisualFactory factory = VisualFactory::Get();
4108 Property::Map properties;
4109 float borderlineWidth = 30.0f;
4110 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4111 float borderlineOffset = 37.4f;
4113 properties[Visual::Property::TYPE] = Visual::COLOR;
4114 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4115 properties["borderlineWidth"] = borderlineWidth;
4116 properties["borderlineColor"] = borderlineColor;
4117 properties["borderlineOffset"] = borderlineOffset;
4119 Visual::Base visual = factory.CreateVisual(properties);
4121 // trigger creation through setting on stage
4122 DummyControl dummy = DummyControl::New(true);
4123 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4124 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4126 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4127 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4128 application.GetScene().Add(dummy);
4130 application.SendNotification();
4131 application.Render();
4133 application.SendNotification();
4134 application.Render();
4136 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4137 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4138 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4139 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4144 VisualFactory factory = VisualFactory::Get();
4145 Property::Map properties;
4146 float borderlineWidth = 30.0f;
4147 float cornerRadius = 70.0f;
4149 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4150 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4151 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4152 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4153 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4154 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4155 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4157 Property::Array stopOffsets;
4158 stopOffsets.PushBack(0.0f);
4159 stopOffsets.PushBack(0.6f);
4160 stopOffsets.PushBack(1.0f);
4161 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4163 Property::Array stopColors;
4164 stopColors.PushBack(Color::RED);
4165 stopColors.PushBack(Color::YELLOW);
4166 stopColors.PushBack(Color::GREEN);
4167 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4169 Visual::Base visual = factory.CreateVisual(properties);
4171 // trigger creation through setting on stage
4172 DummyControl dummy = DummyControl::New(true);
4173 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4174 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4176 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4177 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4178 application.GetScene().Add(dummy);
4180 application.SendNotification();
4181 application.Render();
4183 application.SendNotification();
4184 application.Render();
4186 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4187 // Default corner radius policy is absolute.
4188 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4189 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4190 // Default borderline color is BLACK.
4191 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4192 // Default borderline offset is 0.0f.
4193 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4196 // animated image visual
4198 VisualFactory factory = VisualFactory::Get();
4199 Property::Map properties;
4200 float borderlineWidth = 24.0f;
4201 float borderlineOffset = -1.0f;
4203 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4204 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4205 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4206 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4207 properties["borderlineOffset"] = borderlineOffset;
4209 Visual::Base visual = factory.CreateVisual(properties);
4211 // trigger creation through setting on stage
4212 DummyControl dummy = DummyControl::New(true);
4213 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4214 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4216 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4217 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4218 application.GetScene().Add(dummy);
4220 application.SendNotification();
4221 application.Render();
4223 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4225 application.SendNotification();
4226 application.Render();
4228 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4229 // Default borderline color is BLACK.
4230 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4231 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4234 // vector image visual
4236 VisualFactory factory = VisualFactory::Get();
4237 Property::Map properties;
4238 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4239 float borderlineWidth = 27.0f;
4240 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4242 properties[Visual::Property::TYPE] = Visual::SVG;
4243 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4244 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4245 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4246 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4248 Visual::Base visual = factory.CreateVisual(properties);
4250 // trigger creation through setting on stage
4251 DummyControl dummy = DummyControl::New(true);
4252 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4253 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4255 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4256 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4257 application.GetScene().Add(dummy);
4259 application.SendNotification();
4260 application.Render();
4262 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4264 application.SendNotification();
4265 application.Render();
4267 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4268 // Default corner radius policy is absolute.
4269 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4270 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4271 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4272 // Default borderline offset is 0.0.
4273 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4276 // animated vector image visual
4278 VisualFactory factory = VisualFactory::Get();
4279 Property::Map properties;
4280 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4281 float borderlineWidth = 13.0f;
4282 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4283 float borderlineOffset = 13.0f;
4285 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4286 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4287 properties["cornerRadius"] = cornerRadius;
4288 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4289 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4290 properties["borderlineColor"] = borderlineColor;
4291 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4293 Visual::Base visual = factory.CreateVisual(properties);
4295 // trigger creation through setting on stage
4296 DummyControl dummy = DummyControl::New(true);
4297 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4298 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4300 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4301 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4302 application.GetScene().Add(dummy);
4304 application.SendNotification();
4305 application.Render();
4307 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4309 application.SendNotification();
4310 application.Render();
4312 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4313 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4314 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4315 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4316 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4322 int UtcDaliVisualBorderlineBlendModeTest(void)
4324 ToolkitTestApplication application;
4325 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4326 VisualFactory factory = VisualFactory::Get();
4328 // Case 1 : Test which doesn't support borderline feature.
4330 tet_printf("Test Unsupported visual type\n");
4331 Property::Map propertyMap;
4332 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4333 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4334 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4335 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4337 DummyControl actor = DummyControl::New(true);
4338 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4339 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4340 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4341 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4342 application.GetScene().Add(actor);
4344 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4346 Renderer renderer = actor.GetRendererAt(0);
4348 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4349 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4350 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4352 application.GetScene().Remove(actor);
4355 // Case 2 : Test which support borderline feature.
4357 tet_printf("Test normal case\n");
4358 Property::Map propertyMap;
4359 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4360 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4361 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4362 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4364 DummyControl actor = DummyControl::New(true);
4365 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4366 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4367 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4368 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4369 application.GetScene().Add(actor);
4371 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4373 Renderer renderer = actor.GetRendererAt(0);
4375 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4376 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4377 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4379 application.GetScene().Remove(actor);
4382 // Case 3 : Test which animated borderline.
4384 tet_printf("Test borderline animate case\n");
4385 Property::Map propertyMap;
4386 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4387 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4388 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4390 DummyControl actor = DummyControl::New(true);
4391 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4392 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4393 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4394 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4395 application.GetScene().Add(actor);
4397 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4399 Renderer renderer = actor.GetRendererAt(0);
4401 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4402 // BlendMode is AUTO.
4403 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4405 Animation animation = Animation::New(0.1f);
4406 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4409 application.SendNotification();
4410 application.Render();
4411 application.Render(101u); // End of animation
4413 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4414 // BlendMode is ON_WITHOUT_CULL.
4415 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4417 Animation revanimation = Animation::New(0.1f);
4418 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4419 revanimation.Play();
4421 application.SendNotification();
4422 application.Render();
4423 application.Render(101u); // End of animation
4425 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4426 // BlendMode is still ON_WITHOUT_CULL.
4427 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4429 application.GetScene().Remove(actor);
4432 // Case 4 : Test which animated corner radius occur.
4434 tet_printf("Test borderline animate case\n");
4435 Property::Map propertyMap;
4436 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4437 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4438 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4439 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4441 DummyControl actor = DummyControl::New(true);
4442 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4443 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4444 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4445 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4446 application.GetScene().Add(actor);
4448 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4450 Renderer renderer = actor.GetRendererAt(0);
4452 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4453 // BlendMode is ON_WITHOUT_CULL.
4454 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4456 Animation animation = Animation::New(0.1f);
4457 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4460 application.SendNotification();
4461 application.Render();
4462 application.Render(101u); // End of animation
4464 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4465 // BlendMode is ON_WITHOUT_CULL.
4466 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4468 application.GetScene().Remove(actor);
4474 int UtcDaliVisualBorderlineColorAnimateTest(void)
4476 ToolkitTestApplication application;
4477 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4479 TestGraphicsController& graphics = application.GetGraphicsController();
4480 static std::vector<UniformData> customUniforms =
4482 UniformData("mixColor", Property::Type::VECTOR3),
4483 UniformData("cornerRadius", Property::Type::VECTOR4),
4484 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4485 UniformData("borderlineWidth", Property::Type::FLOAT),
4486 UniformData("borderlineColor", Property::Type::VECTOR4),
4487 UniformData("borderlineOffset", Property::Type::FLOAT),
4489 graphics.AddCustomUniforms(customUniforms);
4492 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4493 const float INITIAL_MIX_OPACITY(0.5f);
4494 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4495 const float INITIAL_ACTOR_OPACITY(1.0f);
4496 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4497 const float TARGET_MIX_OPACITY(0.8f);
4498 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4499 const float TARGET_ACTOR_OPACITY(0.5f);
4501 VisualFactory factory = VisualFactory::Get();
4502 Property::Map propertyMap;
4503 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4504 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4505 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4506 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4507 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4508 Visual::Base visual = factory.CreateVisual(propertyMap);
4510 DummyControl actor = DummyControl::New(true);
4511 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4512 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4513 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4514 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4515 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4516 application.GetScene().Add(actor);
4518 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4520 Animation animation = Animation::New(4.0f);
4521 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4522 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4523 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4524 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4527 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4529 application.SendNotification();
4530 application.Render(0);
4531 application.Render(2000u); // halfway point
4532 application.SendNotification();
4534 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4535 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4536 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4537 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4538 halfwayMixOpacity *= halfwayActorOpacity;
4539 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4540 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4541 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4542 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4544 application.Render(2001u); // go past end
4545 application.SendNotification(); // Trigger signals
4547 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4548 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4549 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4550 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4551 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4559 int UtcDaliColorVisualBlurRadius(void)
4561 ToolkitTestApplication application;
4562 tet_infoline("UtcDaliColorVisualBlurRadius");
4564 static std::vector<UniformData> customUniforms =
4566 UniformData("blurRadius", Property::Type::FLOAT),
4569 TestGraphicsController& graphics = application.GetGraphicsController();
4570 graphics.AddCustomUniforms(customUniforms);
4572 VisualFactory factory = VisualFactory::Get();
4573 Property::Map properties;
4574 float blurRadius = 20.0f;
4576 properties[Visual::Property::TYPE] = Visual::COLOR;
4577 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4578 properties["blurRadius"] = blurRadius;
4580 Visual::Base visual = factory.CreateVisual(properties);
4582 // trigger creation through setting on stage
4583 DummyControl dummy = DummyControl::New(true);
4584 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4585 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4587 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4588 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4589 application.GetScene().Add(dummy);
4591 application.SendNotification();
4592 application.Render();
4594 application.SendNotification();
4595 application.Render();
4597 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4602 int UtcDaliVisualGetType(void)
4604 ToolkitTestApplication application;
4605 tet_infoline("UtcDaliVisualGetType");
4607 VisualFactory factory = VisualFactory::Get();
4610 Property::Map properties;
4611 properties[Visual::Property::TYPE] = Visual::BORDER;
4612 Visual::Base visual = factory.CreateVisual(properties);
4614 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4618 Property::Map properties;
4619 properties[Visual::Property::TYPE] = Visual::COLOR;
4620 Visual::Base visual = factory.CreateVisual(properties);
4622 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4626 Property::Map properties;
4627 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4628 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4629 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4630 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4631 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4632 Property::Array stopColors;
4633 stopColors.PushBack(Color::RED);
4634 stopColors.PushBack(Color::GREEN);
4635 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4636 Visual::Base visual = factory.CreateVisual(properties);
4638 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4642 Property::Map properties;
4643 properties[Visual::Property::TYPE] = Visual::IMAGE;
4644 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4645 Visual::Base visual = factory.CreateVisual(properties);
4647 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4651 Property::Map properties;
4652 properties[Visual::Property::TYPE] = Visual::MESH;
4653 Visual::Base visual = factory.CreateVisual(properties);
4655 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4659 Property::Map properties;
4660 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4661 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4662 Visual::Base visual = factory.CreateVisual(properties);
4664 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4668 Property::Map properties;
4669 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4670 Visual::Base visual = factory.CreateVisual(properties);
4672 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4676 Property::Map properties;
4677 properties[Visual::Property::TYPE] = Visual::TEXT;
4678 Visual::Base visual = factory.CreateVisual(properties);
4680 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4684 Property::Map properties;
4685 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4686 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4687 Visual::Base visual = factory.CreateVisual(properties);
4689 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4693 Property::Map properties;
4694 properties[Visual::Property::TYPE] = Visual::SVG;
4695 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4696 Visual::Base visual = factory.CreateVisual(properties);
4698 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4702 Property::Map properties;
4703 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4704 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4705 Visual::Base visual = factory.CreateVisual(properties);
4707 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4711 Property::Map properties;
4712 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4713 Visual::Base visual = factory.CreateVisual(properties);
4715 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4719 Property::Map properties;
4720 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4721 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4722 Visual::Base visual = factory.CreateVisual(properties);
4724 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4728 Property::Map properties;
4729 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4730 Visual::Base visual = factory.CreateVisual(properties);
4732 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4738 int UtcDaliVisualGetVisualProperty01(void)
4740 ToolkitTestApplication application;
4741 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4743 static std::vector<UniformData> customUniforms =
4745 UniformData("mixColor", Property::Type::VECTOR3),
4746 UniformData("offset", Property::Type::VECTOR2),
4747 UniformData("size", Property::Type::VECTOR2),
4748 UniformData("cornerRadius", Property::Type::VECTOR4),
4749 UniformData("blurRadius", Property::Type::FLOAT),
4750 UniformData("borderlineWidth", Property::Type::FLOAT),
4751 UniformData("borderlineColor", Property::Type::VECTOR4),
4752 UniformData("borderlineOffset", Property::Type::FLOAT),
4753 UniformData("preMultipliedAlpha", Property::Type::FLOAT)};
4755 TestGraphicsController& graphics = application.GetGraphicsController();
4756 graphics.AddCustomUniforms(customUniforms);
4758 VisualFactory factory = VisualFactory::Get();
4759 Property::Map propertyMap;
4760 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4761 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4762 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4763 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4764 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4765 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4766 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4767 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4768 propertyMap.Insert(Visual::Property::PREMULTIPLIED_ALPHA, true);
4769 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4771 DummyControl dummyControl = DummyControl::New(true);
4772 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4773 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4774 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4775 application.GetScene().Add(dummyControl);
4777 application.SendNotification();
4778 application.Render();
4780 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4781 Vector2 targetOffset(0.05f, 0.05f);
4782 Vector2 targetSize(1.1f, 1.1f);
4783 float targetOpacity = 0.5f;
4784 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4785 float targetBlurRadius = 10.0f;
4786 float targetBorderlineWidth = 25.0f;
4787 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4788 float targetBorderlineOffset = -1.0f;
4789 float targetPreMultipliedAlpha = 1.0f;
4791 Animation animation = Animation::New(1.0f);
4792 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4793 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4794 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4795 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4796 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4797 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4798 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4799 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4800 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4803 application.SendNotification();
4804 application.Render();
4805 application.Render(1001u); // End of animation
4807 Property::Map resultMap;
4808 colorVisual.CreatePropertyMap(resultMap);
4810 // Test property values: they should be updated
4811 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4812 DALI_TEST_CHECK(colorValue);
4813 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4815 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4816 Dali::Property::Map* transformMap = transformValue->GetMap();
4817 DALI_TEST_CHECK(transformMap);
4819 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4820 DALI_TEST_CHECK(offsetValue);
4821 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4823 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4824 DALI_TEST_CHECK(sizeValue);
4825 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4827 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4828 DALI_TEST_CHECK(cornerRadiusValue);
4829 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4831 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4832 DALI_TEST_CHECK(blurRadiusValue);
4833 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4835 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4836 DALI_TEST_CHECK(borderlineWidthValue);
4837 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4839 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4840 DALI_TEST_CHECK(borderlineColorValue);
4841 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4843 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4844 DALI_TEST_CHECK(borderlineOffsetValue);
4845 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4847 Property::Value* preMultAlphaValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
4848 DALI_TEST_CHECK(preMultAlphaValue);
4849 DALI_TEST_EQUALS(preMultAlphaValue->Get<bool>(), bool(targetPreMultipliedAlpha), TEST_LOCATION);
4851 // Test uniform values
4852 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4853 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4854 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4855 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4856 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4857 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4858 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4859 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4860 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("preMultipliedAlpha", targetPreMultipliedAlpha), true, TEST_LOCATION);
4862 // Test unregistered visual
4863 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4864 DALI_TEST_CHECK(!property3.object);
4865 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4870 int UtcDaliVisualGetVisualProperty02(void)
4872 ToolkitTestApplication application;
4873 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
4875 static std::vector<UniformData> customUniforms =
4877 UniformData("mixColor", Property::Type::VECTOR3),
4878 UniformData("offset", Property::Type::VECTOR2),
4879 UniformData("size", Property::Type::VECTOR2),
4880 UniformData("cornerRadius", Property::Type::VECTOR4),
4881 UniformData("borderlineWidth", Property::Type::FLOAT),
4882 UniformData("borderlineCOlor", Property::Type::VECTOR4),
4883 UniformData("borderlineOffset", Property::Type::FLOAT),
4884 UniformData("blurRadius", Property::Type::FLOAT),
4887 TestGraphicsController& graphics = application.GetGraphicsController();
4888 graphics.AddCustomUniforms(customUniforms);
4890 VisualFactory factory = VisualFactory::Get();
4891 Property::Map propertyMap;
4892 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4893 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4895 DummyControl dummyControl = DummyControl::New(true);
4896 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4897 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4898 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4899 application.GetScene().Add(dummyControl);
4901 application.SendNotification();
4902 application.Render();
4904 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4905 Vector2 targetOffset(0.05f, 0.05f);
4906 Vector2 targetSize(1.1f, 1.1f);
4907 float targetOpacity = 0.5f;
4908 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
4909 float targetBorderlineWidth = 77.7f;
4910 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
4911 float targetBorderlineOffset = 1.0f;
4912 float targetBlurRadius = 10.0f;
4914 // Should work when the properties are not set before
4915 Animation animation = Animation::New(1.0f);
4916 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
4917 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
4918 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
4919 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
4920 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
4921 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
4922 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
4923 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
4924 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
4927 application.SendNotification();
4928 application.Render();
4929 application.Render(1001u); // End of animation
4931 Property::Map resultMap;
4932 colorVisual.CreatePropertyMap(resultMap);
4934 // Test property values: they should be updated
4935 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4936 DALI_TEST_CHECK(colorValue);
4937 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4939 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4940 Dali::Property::Map* transformMap = transformValue->GetMap();
4941 DALI_TEST_CHECK(transformMap);
4943 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4944 DALI_TEST_CHECK(offsetValue);
4945 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4947 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4948 DALI_TEST_CHECK(sizeValue);
4949 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4951 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4952 DALI_TEST_CHECK(cornerRadiusValue);
4953 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4955 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4956 DALI_TEST_CHECK(borderlineWidthValue);
4957 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4959 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4960 DALI_TEST_CHECK(borderlineColorValue);
4961 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4963 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4964 DALI_TEST_CHECK(borderlineOffsetValue);
4965 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4967 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4968 DALI_TEST_CHECK(blurRadiusValue);
4969 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4971 // Test uniform values
4972 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4973 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4974 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4975 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4976 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4981 int UtcDaliVisualGetVisualProperty03(void)
4983 ToolkitTestApplication application;
4984 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
4986 static std::vector<UniformData> customUniforms =
4988 UniformData("cornerRadius", Property::Type::VECTOR4),
4989 UniformData("borderlineWidth", Property::Type::FLOAT),
4990 UniformData("borderlineColor", Property::Type::VECTOR4),
4991 UniformData("borderlineOffset", Property::Type::FLOAT),
4994 TestGraphicsController& graphics = application.GetGraphicsController();
4995 graphics.AddCustomUniforms(customUniforms);
4997 VisualFactory factory = VisualFactory::Get();
4998 Property::Map propertyMap;
4999 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5000 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5002 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5004 DummyControl dummyControl = DummyControl::New(true);
5005 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5006 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5007 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5008 application.GetScene().Add(dummyControl);
5010 // Wait for image loading
5011 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5013 application.SendNotification();
5014 application.Render();
5016 float targetOpacity = 0.5f;
5017 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5018 float targetBorderlineWidth = 10.0f;
5019 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5020 float targetBorderlineOffset = -1.5f;
5022 Animation animation = Animation::New(1.0f);
5023 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5024 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5025 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5026 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5027 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5030 application.SendNotification();
5031 application.Render();
5032 application.Render(1001u); // End of animation
5034 Property::Map resultMap;
5035 imageVisual.CreatePropertyMap(resultMap);
5037 // Test property values: they should be updated
5038 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5039 DALI_TEST_CHECK(colorValue);
5040 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5042 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5043 DALI_TEST_CHECK(cornerRadiusValue);
5044 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5046 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5047 DALI_TEST_CHECK(borderlineWidthValue);
5048 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5050 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5051 DALI_TEST_CHECK(borderlineColorValue);
5052 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5054 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5055 DALI_TEST_CHECK(borderlineOffsetValue);
5056 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5058 // Test uniform value
5059 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5060 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5061 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5062 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5067 int UtcDaliVisualGetVisualProperty04(void)
5069 ToolkitTestApplication application;
5070 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5072 static std::vector<UniformData> customUniforms =
5074 UniformData("cornerRadius", Property::Type::VECTOR4),
5077 TestGraphicsController& graphics = application.GetGraphicsController();
5078 graphics.AddCustomUniforms(customUniforms);
5080 Vector2 start(-1.f, -1.f);
5081 Vector2 end(1.f, 1.f);
5082 Property::Array stopColors;
5083 stopColors.PushBack(Color::RED);
5084 stopColors.PushBack(Color::GREEN);
5086 VisualFactory factory = VisualFactory::Get();
5087 Property::Map propertyMap;
5088 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5089 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5090 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5091 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5092 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5093 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5094 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5096 DummyControl dummyControl = DummyControl::New(true);
5097 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5098 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5099 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5100 application.GetScene().Add(dummyControl);
5102 application.SendNotification();
5103 application.Render();
5105 float targetOpacity = 0.5f;
5106 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5108 Animation animation = Animation::New(1.0f);
5109 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5110 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5113 application.SendNotification();
5114 application.Render();
5115 application.Render(1001u); // End of animation
5117 Property::Map resultMap;
5118 gradientVisual.CreatePropertyMap(resultMap);
5120 // Test property values: they should be updated
5121 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5122 DALI_TEST_CHECK(colorValue);
5123 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5125 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5126 DALI_TEST_CHECK(cornerRadiusValue);
5127 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5129 // Test uniform value
5130 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5135 int UtcDaliVisualGetVisualProperty05(void)
5137 ToolkitTestApplication application;
5138 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5140 static std::vector<UniformData> customUniforms =
5142 UniformData("cornerRadius", Property::Type::VECTOR4),
5143 UniformData("borderlineWidth", Property::Type::FLOAT),
5144 UniformData("borderlineColor", Property::Type::VECTOR4),
5145 UniformData("borderlineOffset", Property::Type::FLOAT),
5148 TestGraphicsController& graphics = application.GetGraphicsController();
5149 graphics.AddCustomUniforms(customUniforms);
5151 VisualFactory factory = VisualFactory::Get();
5152 Property::Map propertyMap;
5153 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5154 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5156 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5158 DummyControl dummyControl = DummyControl::New(true);
5159 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5160 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5161 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5162 application.GetScene().Add(dummyControl);
5164 application.SendNotification();
5165 application.Render();
5167 // Wait for image loading
5168 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5170 application.SendNotification();
5171 application.Render();
5173 float targetOpacity = 0.5f;
5174 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5175 float targetBorderlineWidth = 10.0f;
5176 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5177 float targetBorderlineOffset = -1.5f;
5179 Animation animation = Animation::New(1.0f);
5180 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5181 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5182 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5183 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5184 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5187 application.SendNotification();
5188 application.Render();
5189 application.Render(1001u); // End of animation
5191 Property::Map resultMap;
5192 svgVisual.CreatePropertyMap(resultMap);
5194 // Test property values: they should be updated
5195 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5196 DALI_TEST_CHECK(colorValue);
5197 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5199 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5200 DALI_TEST_CHECK(cornerRadiusValue);
5201 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5203 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5204 DALI_TEST_CHECK(borderlineWidthValue);
5205 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5207 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5208 DALI_TEST_CHECK(borderlineColorValue);
5209 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5211 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5212 DALI_TEST_CHECK(borderlineOffsetValue);
5213 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5215 // Currently test with multiple program doesn't work well. will fix another day
5216 // Test uniform value
5217 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5218 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5219 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5220 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5225 int UtcDaliVisualGetVisualProperty06(void)
5227 ToolkitTestApplication application;
5228 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5230 static std::vector<UniformData> customUniforms =
5232 UniformData("cornerRadius", Property::Type::VECTOR4),
5233 UniformData("borderlineWidth", Property::Type::FLOAT),
5234 UniformData("borderlineColor", Property::Type::VECTOR4),
5235 UniformData("borderlineOffset", Property::Type::FLOAT),
5238 TestGraphicsController& graphics = application.GetGraphicsController();
5239 graphics.AddCustomUniforms(customUniforms);
5241 VisualFactory factory = VisualFactory::Get();
5242 Property::Map propertyMap;
5243 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5244 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5246 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5248 DummyControl dummyControl = DummyControl::New(true);
5249 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5250 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5251 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5252 application.GetScene().Add(dummyControl);
5254 application.SendNotification();
5255 application.Render();
5257 // Wait for image loading
5258 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5260 application.SendNotification();
5261 application.Render();
5263 float targetOpacity = 0.5f;
5264 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5265 float targetBorderlineWidth = 10.0f;
5266 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5267 float targetBorderlineOffset = -1.5f;
5269 Animation animation = Animation::New(1.0f);
5270 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5271 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5272 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5273 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5274 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5277 application.SendNotification();
5278 application.Render();
5279 application.Render(1001u); // End of animation
5281 Property::Map resultMap;
5282 animatedImageVisual.CreatePropertyMap(resultMap);
5284 // Test property values: they should be updated
5285 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5286 DALI_TEST_CHECK(colorValue);
5287 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5289 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5290 DALI_TEST_CHECK(cornerRadiusValue);
5291 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5293 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5294 DALI_TEST_CHECK(borderlineWidthValue);
5295 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5297 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5298 DALI_TEST_CHECK(borderlineColorValue);
5299 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5301 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5302 DALI_TEST_CHECK(borderlineOffsetValue);
5303 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5305 // Currently test with multiple program doesn't work well. will fix another day
5306 // Test uniform value
5307 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5308 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5309 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5310 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5315 int UtcDaliVisualGetVisualProperty07(void)
5317 ToolkitTestApplication application;
5318 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5320 static std::vector<UniformData> customUniforms =
5322 UniformData("cornerRadius", Property::Type::VECTOR4),
5323 UniformData("borderlineWidth", Property::Type::FLOAT),
5324 UniformData("borderlineColor", Property::Type::VECTOR4),
5325 UniformData("borderlineOffset", Property::Type::FLOAT),
5328 TestGraphicsController& graphics = application.GetGraphicsController();
5329 graphics.AddCustomUniforms(customUniforms);
5331 VisualFactory factory = VisualFactory::Get();
5332 Property::Map propertyMap;
5333 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5334 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5336 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5338 DummyControl dummyControl = DummyControl::New(true);
5339 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5340 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5341 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5342 application.GetScene().Add(dummyControl);
5344 application.SendNotification();
5345 application.Render();
5347 // Wait for image loading
5348 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5350 application.SendNotification();
5351 application.Render();
5353 float targetOpacity = 0.5f;
5354 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5355 float targetBorderlineWidth = 10.0f;
5356 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5357 float targetBorderlineOffset = -1.5f;
5359 Animation animation = Animation::New(1.0f);
5360 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5361 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5362 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5363 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5364 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5367 application.SendNotification();
5368 application.Render();
5369 application.Render(1001u); // End of animation
5371 Property::Map resultMap;
5372 animatedVectorVisual.CreatePropertyMap(resultMap);
5374 // Test property values: they should be updated
5375 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5376 DALI_TEST_CHECK(colorValue);
5377 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5379 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5380 DALI_TEST_CHECK(cornerRadiusValue);
5381 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5383 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5384 DALI_TEST_CHECK(borderlineWidthValue);
5385 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5387 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5388 DALI_TEST_CHECK(borderlineColorValue);
5389 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5391 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5392 DALI_TEST_CHECK(borderlineOffsetValue);
5393 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5395 // Currently test with multiple program doesn't work well. will fix another day
5396 // Test uniform value
5397 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5398 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5399 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5400 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5405 int UtcDaliVisualUpdateProperty(void)
5407 ToolkitTestApplication application;
5408 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5410 VisualFactory factory = VisualFactory::Get();
5411 Property::Map propertyMap;
5412 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5413 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5414 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5415 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5417 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5419 DummyControl dummyControl = DummyControl::New(true);
5420 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5421 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5422 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5423 application.GetScene().Add(dummyControl);
5425 application.SendNotification();
5426 application.Render();
5428 // Wait for image loading
5429 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5431 application.SendNotification();
5432 application.Render();
5434 Property::Map originalMap;
5435 imageVisual.CreatePropertyMap(originalMap);
5437 float targetOpacity = 0.5f;
5438 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5439 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5440 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5442 Property::Map targetPropertyMap;
5443 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5444 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5445 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5446 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5447 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5449 // Update Properties
5450 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5452 Property::Map resultMap;
5453 imageVisual.CreatePropertyMap(resultMap);
5455 // Test property values: they should be updated
5456 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5457 DALI_TEST_CHECK(colorValue);
5458 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5460 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5461 DALI_TEST_CHECK(urlValue);
5462 // NOTE : ImageVisual URL must NOT changed.
5463 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5465 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5466 DALI_TEST_CHECK(preMultipliedValue);
5467 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5469 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5470 DALI_TEST_CHECK(visualFittingModeValue);
5471 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5476 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5478 ToolkitTestApplication application;
5479 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5481 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5483 VisualFactory factory = VisualFactory::Get();
5484 Property::Map propertyMap;
5486 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5487 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5489 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5491 DummyControl dummyControl = DummyControl::New(true);
5492 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5493 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5494 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5495 application.GetScene().Add(dummyControl);
5497 application.SendNotification();
5498 application.Render();
5500 // Wait for image loading
5501 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5503 application.SendNotification();
5504 application.Render();
5508 Renderer renderer = dummyControl.GetRendererAt(0);
5509 Shader shader = renderer.GetShader();
5510 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5511 Property::Map* map = value.GetMap();
5512 DALI_TEST_CHECK(map);
5514 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5515 DALI_TEST_CHECK(fragment);
5516 std::string fragmentShader;
5517 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5518 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5519 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5521 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5522 std::string vertexShader;
5523 DALI_TEST_CHECK(vertex->Get(vertexShader));
5524 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5525 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5528 callStack.Enable(true);
5530 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5532 Property::Map targetPropertyMap;
5533 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5534 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5536 // Update Properties with CornerRadius
5537 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5539 Property::Map resultMap;
5540 imageVisual.CreatePropertyMap(resultMap);
5542 // Test property values: they should be updated
5543 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5544 DALI_TEST_CHECK(cornerRadiusValue);
5545 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5547 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5548 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5549 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5553 Renderer renderer = dummyControl.GetRendererAt(0);
5554 Shader shader = renderer.GetShader();
5555 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5556 Property::Map* map = value.GetMap();
5557 DALI_TEST_CHECK(map);
5559 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5560 DALI_TEST_CHECK(fragment);
5561 std::string fragmentShader;
5562 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5563 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5564 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5566 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5567 std::string vertexShader;
5568 DALI_TEST_CHECK(vertex->Get(vertexShader));
5569 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5570 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5573 // Send shader compile signal
5574 application.SendNotification();
5575 application.Render();
5577 callStack.Enable(false);
5579 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5581 callStack.Enable(true);
5583 float targetBorderlineWidth = 10.0f;
5584 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5585 float targetBorderlineOffset = -0.3f;
5587 Property::Map targetPropertyMap2;
5588 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5589 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5590 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5591 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5592 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5594 // Update Properties with Borderline
5595 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5597 Property::Map resultMap2;
5598 imageVisual.CreatePropertyMap(resultMap2);
5600 // Test property values: they should be updated
5601 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5602 DALI_TEST_CHECK(cornerRadiusValue);
5603 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5605 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5606 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5607 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5609 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5610 DALI_TEST_CHECK(borderlineWidthValue);
5611 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5613 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5614 DALI_TEST_CHECK(borderlineColorValue);
5615 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5617 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5618 DALI_TEST_CHECK(borderlineOffsetValue);
5619 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5623 Renderer renderer = dummyControl.GetRendererAt(0);
5624 Shader shader = renderer.GetShader();
5625 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5626 Property::Map* map = value.GetMap();
5627 DALI_TEST_CHECK(map);
5629 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5630 DALI_TEST_CHECK(fragment);
5631 std::string fragmentShader;
5632 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5633 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5634 // Note : mAlwaysUsingCornerRadius is true.
5635 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5637 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5638 std::string vertexShader;
5639 DALI_TEST_CHECK(vertex->Get(vertexShader));
5640 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5641 // Note : mAlwaysUsingCornerRadius is true.
5642 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5645 // Send shader compile signal
5646 application.SendNotification();
5647 application.Render();
5649 callStack.Enable(false);
5651 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5653 callStack.Enable(true);
5655 Property::Map targetPropertyMap3;
5656 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5657 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5658 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5659 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5660 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5662 // Update Properties into zero
5663 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5665 Property::Map resultMap3;
5666 imageVisual.CreatePropertyMap(resultMap3);
5668 // Test property values: they should be updated
5669 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5670 DALI_TEST_CHECK(cornerRadiusValue);
5671 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5673 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5674 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5675 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5677 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5678 DALI_TEST_CHECK(borderlineWidthValue);
5679 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5681 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5682 DALI_TEST_CHECK(borderlineColorValue);
5683 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5685 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5686 DALI_TEST_CHECK(borderlineOffsetValue);
5687 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5691 Renderer renderer = dummyControl.GetRendererAt(0);
5692 Shader shader = renderer.GetShader();
5693 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5694 Property::Map* map = value.GetMap();
5695 DALI_TEST_CHECK(map);
5697 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5698 DALI_TEST_CHECK(fragment);
5699 std::string fragmentShader;
5700 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5701 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5702 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5703 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5705 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5706 std::string vertexShader;
5707 DALI_TEST_CHECK(vertex->Get(vertexShader));
5708 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5709 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5710 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5713 // Send shader compile signal
5714 application.SendNotification();
5715 application.Render();
5717 callStack.Enable(false);
5718 // Shader not changed
5719 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5724 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5726 ToolkitTestApplication application;
5727 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5729 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5731 VisualFactory factory = VisualFactory::Get();
5732 Property::Map propertyMap;
5734 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5735 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5737 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5739 DummyControl dummyControl = DummyControl::New(true);
5740 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5741 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5742 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5743 application.GetScene().Add(dummyControl);
5745 application.SendNotification();
5746 application.Render();
5748 // Wait for image loading
5749 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5751 application.SendNotification();
5752 application.Render();
5756 Renderer renderer = dummyControl.GetRendererAt(0);
5757 Shader shader = renderer.GetShader();
5758 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5759 Property::Map* map = value.GetMap();
5760 DALI_TEST_CHECK(map);
5762 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5763 DALI_TEST_CHECK(fragment);
5764 std::string fragmentShader;
5765 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5766 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5767 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5769 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5770 std::string vertexShader;
5771 DALI_TEST_CHECK(vertex->Get(vertexShader));
5772 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5773 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5776 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5778 Property::Map targetPropertyMap;
5779 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5782 callStack.Enable(true);
5784 // Update Properties with CornerRadius
5785 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5787 Property::Map resultMap;
5788 imageVisual.CreatePropertyMap(resultMap);
5790 // Test property values: they should be updated
5791 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5792 DALI_TEST_CHECK(cornerRadiusValue);
5793 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5797 Renderer renderer = dummyControl.GetRendererAt(0);
5798 Shader shader = renderer.GetShader();
5799 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5800 Property::Map* map = value.GetMap();
5801 DALI_TEST_CHECK(map);
5803 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5804 DALI_TEST_CHECK(fragment);
5805 std::string fragmentShader;
5806 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5807 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5808 // Note : corner radius is zero. so we don't change shader!
5809 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5811 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5812 std::string vertexShader;
5813 DALI_TEST_CHECK(vertex->Get(vertexShader));
5814 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5815 // Note : corner radius is zero. so we don't change shader!
5816 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5819 // Send shader compile signal
5820 application.SendNotification();
5821 application.Render();
5823 callStack.Enable(false);
5825 // Shader doesn't changed
5826 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5828 callStack.Enable(true);
5830 float targetBorderlineWidth = 0.0f;
5831 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5832 float targetBorderlineOffset = -1.0f;
5834 Property::Map targetPropertyMap2;
5835 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5836 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5837 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5839 // Update Properties with Borderline
5840 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5842 Property::Map resultMap2;
5843 imageVisual.CreatePropertyMap(resultMap2);
5845 // Test property values: they should be updated
5846 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5847 DALI_TEST_CHECK(borderlineWidthValue);
5848 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5850 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5851 DALI_TEST_CHECK(borderlineColorValue);
5852 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5854 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5855 DALI_TEST_CHECK(borderlineOffsetValue);
5856 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5860 Renderer renderer = dummyControl.GetRendererAt(0);
5861 Shader shader = renderer.GetShader();
5862 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5863 Property::Map* map = value.GetMap();
5864 DALI_TEST_CHECK(map);
5866 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5867 DALI_TEST_CHECK(fragment);
5868 std::string fragmentShader;
5869 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5870 // Note : borderline width is zero. so we don't change shader!
5871 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5872 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5874 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5875 std::string vertexShader;
5876 DALI_TEST_CHECK(vertex->Get(vertexShader));
5877 // Note : borderline width is zero. so we don't change shader!
5878 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5879 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5882 // Send shader compile signal
5883 application.SendNotification();
5884 application.Render();
5886 callStack.Enable(false);
5888 // Shader doesn't changed
5889 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5894 int UtcDaliVisualUpdatePropertyChangeShader03(void)
5896 ToolkitTestApplication application;
5897 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
5899 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5901 VisualFactory factory = VisualFactory::Get();
5902 Property::Map propertyMap;
5904 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
5905 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
5907 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5909 DummyControl dummyControl = DummyControl::New(true);
5910 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5911 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5912 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5913 application.GetScene().Add(dummyControl);
5915 application.SendNotification();
5916 application.Render();
5918 application.SendNotification();
5919 application.Render();
5923 Renderer renderer = dummyControl.GetRendererAt(0);
5924 Shader shader = renderer.GetShader();
5925 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5926 Property::Map* map = value.GetMap();
5927 DALI_TEST_CHECK(map);
5929 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5930 DALI_TEST_CHECK(fragment);
5931 std::string fragmentShader;
5932 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5933 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
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_BLUR 1") == std::string::npos);
5941 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5942 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5945 float targetBlurRadius = 15.0f;
5946 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
5948 Property::Map targetPropertyMap;
5949 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
5950 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5951 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
5954 callStack.Enable(true);
5956 // Update Properties with CornerRadius
5957 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5959 Property::Map resultMap;
5960 imageVisual.CreatePropertyMap(resultMap);
5962 // Test property values: they should be updated
5963 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5964 DALI_TEST_CHECK(blurRadiusValue);
5965 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5967 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5968 DALI_TEST_CHECK(cornerRadiusValue);
5969 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5973 Renderer renderer = dummyControl.GetRendererAt(0);
5974 Shader shader = renderer.GetShader();
5975 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5976 Property::Map* map = value.GetMap();
5977 DALI_TEST_CHECK(map);
5979 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5980 DALI_TEST_CHECK(fragment);
5981 std::string fragmentShader;
5982 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5983 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
5984 // Note : We ignore borderline when blur radius occured
5985 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5986 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5988 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5989 std::string vertexShader;
5990 DALI_TEST_CHECK(vertex->Get(vertexShader));
5991 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
5992 // Note : We ignore borderline when blur radius occured
5993 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5994 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5997 // Send shader compile signal
5998 application.SendNotification();
5999 application.Render();
6001 callStack.Enable(false);
6004 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6006 callStack.Enable(true);
6008 Property::Map targetPropertyMap2;
6009 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6010 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
6011 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6013 // Update Properties with CornerRadius
6014 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6016 Property::Map resultMap2;
6017 imageVisual.CreatePropertyMap(resultMap2);
6019 // Test property values: they should be updated
6020 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6021 DALI_TEST_CHECK(blurRadiusValue);
6022 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6024 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6025 DALI_TEST_CHECK(cornerRadiusValue);
6026 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6030 Renderer renderer = dummyControl.GetRendererAt(0);
6031 Shader shader = renderer.GetShader();
6032 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6033 Property::Map* map = value.GetMap();
6034 DALI_TEST_CHECK(map);
6036 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6037 DALI_TEST_CHECK(fragment);
6038 std::string fragmentShader;
6039 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6040 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6041 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6042 // Note : We ignore borderline when blur radius occured
6043 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6044 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6046 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6047 std::string vertexShader;
6048 DALI_TEST_CHECK(vertex->Get(vertexShader));
6049 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6050 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6051 // Note : We ignore borderline when blur radius occured
6052 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6053 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6056 // Send shader compile signal
6057 application.SendNotification();
6058 application.Render();
6060 callStack.Enable(false);
6062 // Shader not changed
6063 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6068 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6070 ToolkitTestApplication application;
6071 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6073 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6075 VisualFactory factory = VisualFactory::Get();
6076 Property::Map propertyMap;
6078 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6079 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6080 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6082 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6084 DummyControl dummyControl = DummyControl::New(true);
6085 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6086 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6087 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6088 application.GetScene().Add(dummyControl);
6090 application.SendNotification();
6091 application.Render();
6093 // Wait for image loading
6094 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6096 application.SendNotification();
6097 application.Render();
6101 Renderer renderer = dummyControl.GetRendererAt(0);
6102 Shader shader = renderer.GetShader();
6103 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6104 Property::Map* map = value.GetMap();
6105 DALI_TEST_CHECK(map);
6107 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6108 DALI_TEST_CHECK(fragment);
6109 std::string fragmentShader;
6110 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6111 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6112 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6114 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6115 std::string vertexShader;
6116 DALI_TEST_CHECK(vertex->Get(vertexShader));
6117 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6118 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6121 callStack.Enable(true);
6123 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6125 Animation animation = Animation::New(1.0f);
6126 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6129 application.SendNotification();
6130 application.Render();
6131 application.Render(1001u); // End of animation
6135 Renderer renderer = dummyControl.GetRendererAt(0);
6136 Shader shader = renderer.GetShader();
6137 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6138 Property::Map* map = value.GetMap();
6139 DALI_TEST_CHECK(map);
6141 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6142 DALI_TEST_CHECK(fragment);
6143 std::string fragmentShader;
6144 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6145 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6146 // Note : mAlwaysUsingCornerRadius is true.
6147 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6149 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6150 std::string vertexShader;
6151 DALI_TEST_CHECK(vertex->Get(vertexShader));
6152 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6153 // Note : mAlwaysUsingCornerRadius is true.
6154 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6156 callStack.Enable(false);
6157 // Shader not changed
6158 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6160 callStack.Enable(true);
6162 float targetBorderlineWidth = 10.0f;
6163 Property::Map targetPropertyMap;
6164 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6166 // Update Properties with CornerRadius
6167 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6169 Property::Map resultMap;
6170 imageVisual.CreatePropertyMap(resultMap);
6172 // Test property values: they should be updated
6173 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6174 DALI_TEST_CHECK(cornerRadiusValue);
6175 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6177 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6178 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6179 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6181 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6182 DALI_TEST_CHECK(borderlineWidthValue);
6183 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6187 Renderer renderer = dummyControl.GetRendererAt(0);
6188 Shader shader = renderer.GetShader();
6189 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6190 Property::Map* map = value.GetMap();
6191 DALI_TEST_CHECK(map);
6193 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6194 DALI_TEST_CHECK(fragment);
6195 std::string fragmentShader;
6196 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6197 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6198 // Note : mAlwaysUsingCornerRadius is true.
6199 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6201 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6202 std::string vertexShader;
6203 DALI_TEST_CHECK(vertex->Get(vertexShader));
6204 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6205 // Note : mAlwaysUsingCornerRadius is true.
6206 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6209 // Send shader compile signal
6210 application.SendNotification();
6211 application.Render();
6213 callStack.Enable(false);
6215 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));