2 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <dali-toolkit-test-suite-utils.h>
22 #include <dali-toolkit/dali-toolkit.h>
23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
24 #include <dali-toolkit/devel-api/controls/control-devel.h>
25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
29 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
34 #include <dali/devel-api/actors/actor-devel.h>
35 #include <dali/devel-api/object/handle-devel.h>
36 #include <dali/devel-api/text-abstraction/font-client.h>
37 #include <toolkit-event-thread-callback.h>
39 #include "dummy-control.h"
42 using namespace Dali::Toolkit;
46 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
47 const char* TEST_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
48 const char* TEST_NPATCH_FILE_NAME = TEST_RESOURCE_DIR "/button-up.9.png";
49 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
50 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
51 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
53 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
57 Property::Map DefaultTransform()
59 Property::Map transformMap;
61 .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
62 .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
63 .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
64 .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
65 .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
66 .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
72 if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
74 for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
76 const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
78 Property::Value* valueSet = NULL;
79 if(valueGet.first.type == Property::Key::INDEX)
81 valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
85 // Get Key is a string so searching Set Map for a string key
86 valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
91 if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
93 tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
96 else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
98 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
101 else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
103 tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
106 else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
108 tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
111 else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
113 Vector2 vector2Get = valueGet.second.Get<Vector2>();
114 Vector2 vector2Set = valueSet->Get<Vector2>();
115 tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
118 else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
120 Vector4 vector4Get = valueGet.second.Get<Vector4>();
121 Vector4 vector4Set = valueSet->Get<Vector4>();
122 tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
128 if(valueGet.first.type == Property::Key::INDEX)
130 tet_printf(" The key %d doesn't exist.", valueGet.first.indexKey);
134 tet_printf(" The key %s doesn't exist.", valueGet.first.stringKey.c_str());
146 void dali_visual_startup(void)
148 test_return_value = TET_UNDEF;
151 void dali_visual_cleanup(void)
153 test_return_value = TET_PASS;
156 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
159 visual.CreatePropertyMap(map);
160 Property::Value* value = map.Find(mixColorIndex);
161 DALI_TEST_CHECK(value);
163 DALI_TEST_CHECK(value->Get(mixColor1));
164 DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
166 value = map.Find(Visual::Property::MIX_COLOR);
167 DALI_TEST_CHECK(value);
169 DALI_TEST_CHECK(value->Get(mixColor2));
170 DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
172 value = map.Find(Visual::Property::OPACITY);
173 DALI_TEST_CHECK(value);
175 DALI_TEST_CHECK(value->Get(opacity));
176 DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
179 int UtcDaliVisualCopyAndAssignment(void)
181 ToolkitTestApplication application;
182 tet_infoline("UtcDaliVisualCopyAndAssignment");
184 VisualFactory factory = VisualFactory::Get();
185 Property::Map propertyMap;
186 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
187 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
188 Visual::Base visual = factory.CreateVisual(propertyMap);
190 Visual::Base visualCopy(visual);
191 DALI_TEST_CHECK(visual == visualCopy);
193 Visual::Base emptyVisual;
194 Visual::Base emptyVisualCopy(emptyVisual);
195 DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
197 Visual::Base visualEquals;
198 visualEquals = visual;
199 DALI_TEST_CHECK(visual == visualEquals);
201 Visual::Base emptyVisualEquals;
202 emptyVisualEquals = emptyVisual;
203 DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
207 DALI_TEST_CHECK(visual = visualCopy);
212 int UtcDaliVisualSetName01(void)
214 ToolkitTestApplication application;
215 tet_infoline("UtcDaliVisualSetName");
217 VisualFactory factory = VisualFactory::Get();
218 Property::Map propertyMap;
219 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
220 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
221 Visual::Base visual = factory.CreateVisual(propertyMap);
223 const char* visualName = "backgroundVisual";
224 visual.SetName(visualName);
226 DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
231 int UtcDaliVisualSetGetDepthIndex(void)
233 ToolkitTestApplication application;
234 tet_infoline("UtcDaliVisualSetDepthIndex");
236 VisualFactory factory = VisualFactory::Get();
237 Property::Map propertyMap;
238 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
239 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
240 Visual::Base visual = factory.CreateVisual(propertyMap);
242 visual.SetDepthIndex(1);
244 DummyControl dummyControl = DummyControl::New(true);
245 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
246 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
248 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
249 application.GetScene().Add(dummyControl);
251 int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
252 DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
253 DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
255 visual.SetDepthIndex(-1);
256 depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
257 DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
258 DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
263 int UtcDaliVisualSize(void)
265 ToolkitTestApplication application;
266 tet_infoline("UtcDaliVisualSize");
268 VisualFactory factory = VisualFactory::Get();
269 Vector2 controlSize(20.f, 30.f);
273 Dali::Property::Map map;
274 map[Toolkit::Visual::Property::TYPE] = Visual::COLOR;
275 map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
277 Visual::Base colorVisual = factory.CreateVisual(map);
278 colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
280 colorVisual.GetNaturalSize(naturalSize);
281 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
285 map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
286 map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
287 map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
288 map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
289 Visual::Base imageVisual = factory.CreateVisual(map);
290 imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
292 imageVisual.GetNaturalSize(naturalSize);
293 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
295 // n patch visual is tested in the utc-Dali-VisualFactory.cpp
298 float borderSize = 5.f;
300 map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
301 map[BorderVisual::Property::COLOR] = Color::RED;
302 map[BorderVisual::Property::SIZE] = borderSize;
303 Visual::Base borderVisual = factory.CreateVisual(map);
304 borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
305 borderVisual.GetNaturalSize(naturalSize);
306 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
308 // gradient gradientVisual
309 Property::Map propertyMap;
310 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
311 Vector2 start(-1.f, -1.f);
312 Vector2 end(1.f, 1.f);
313 propertyMap.Insert("mixColor", Color::MAGENTA);
314 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
315 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
316 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
317 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
318 Property::Array stopColors;
319 stopColors.PushBack(Color::RED);
320 stopColors.PushBack(Color::GREEN);
321 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
322 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
323 gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
324 gradientVisual.GetNaturalSize(naturalSize);
325 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
327 // animated gradient visual
328 Vector2 animated_gradient_visual_size(10.f, 10.f);
330 propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
331 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
332 animatedGradientVisual.GetNaturalSize(naturalSize);
333 animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
334 DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
337 Visual::Base svgVisual = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
338 svgVisual.GetNaturalSize(naturalSize);
340 // <svg width="100" height="100">
341 // <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
343 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION);
345 // svg visual with a size
346 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(200, 200));
347 svgVisual2.GetNaturalSize(naturalSize);
348 DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION); // Natural size should still be 100, 100
352 // Load some fonts to get the same metrics on different platforms.
353 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
354 fontClient.SetDpi(96u, 96u);
356 char* pathNamePtr = get_current_dir_name();
357 const std::string pathName(pathNamePtr);
360 fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
362 // Create a TextVisual with a font size of 12 first
364 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
365 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
366 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
367 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
369 Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
370 Vector2 smallTextVisualNaturalSize;
371 smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
373 // Then create a TextVisual with a font size of 20
374 propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
375 Visual::Base largeTextVisual = factory.CreateVisual(propertyMap);
376 Vector2 largeTextVisualNaturalSize;
377 largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
379 // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
380 DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
381 smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
383 // The height returned for a particular width should also be greater for the large text visual
384 DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
386 //AnimatedImageVisual
387 Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
388 animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
389 animatedImageVisual.GetNaturalSize(naturalSize);
390 // TEST_GIF_FILE: anim.gif
391 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
392 DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
397 int UtcDaliVisualSetOnOffScene(void)
399 ToolkitTestApplication application;
400 tet_infoline("UtcDaliVisualSetOnOffScene");
402 VisualFactory factory = VisualFactory::Get();
403 Property::Map propertyMap;
404 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
405 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
406 Visual::Base visual = factory.CreateVisual(propertyMap);
408 DummyControl actor = DummyControl::New(true);
409 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
410 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
412 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
414 application.SendNotification();
415 application.Render(0);
416 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
418 application.GetScene().Add(actor);
420 application.SendNotification();
421 application.Render(0);
422 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
424 application.GetScene().Remove(actor);
426 application.SendNotification();
427 application.Render(0);
428 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
433 int UtcDaliVisualSetOnOffScene2(void)
435 ToolkitTestApplication application;
436 tet_infoline("UtcDaliVisualSetOnOffScene2");
438 VisualFactory factory = VisualFactory::Get();
439 Property::Map propertyMap;
440 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
441 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
442 Visual::Base visual = factory.CreateVisual(propertyMap);
444 DummyControl actor = DummyControl::New(true);
445 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
446 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
448 actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
450 application.SendNotification();
451 application.Render(0);
452 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
455 application.GetScene().Add(actor);
457 application.SendNotification();
458 application.Render(0);
459 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
460 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
461 Renderer renderer = actor.GetRendererAt(0);
462 auto textures = renderer.GetTextures();
463 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
465 application.GetScene().Remove(actor);
467 application.SendNotification();
468 application.Render(0);
469 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
472 application.GetScene().Add(actor);
474 application.SendNotification();
475 application.Render(0);
476 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
477 DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
478 renderer = actor.GetRendererAt(0);
479 textures = renderer.GetTextures();
480 DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
482 application.GetScene().Remove(actor);
484 application.SendNotification();
485 application.Render(0);
486 DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
491 int UtcDaliVisualGetPropertyMap1(void)
493 ToolkitTestApplication application;
494 tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
496 VisualFactory factory = VisualFactory::Get();
497 Property::Map propertyMap;
498 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
499 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
500 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
501 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
502 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
503 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
504 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
505 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
506 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
508 Property::Map resultMap;
509 colorVisual.CreatePropertyMap(resultMap);
511 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
512 DALI_TEST_CHECK(typeValue);
513 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
515 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
516 DALI_TEST_CHECK(colorValue);
517 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
519 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
520 DALI_TEST_CHECK(cornerRadiusValue);
521 DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
523 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
524 DALI_TEST_CHECK(cornerRadiusPolicyValue);
525 DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
527 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
528 DALI_TEST_CHECK(borderlineWidthValue);
529 DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
531 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
532 DALI_TEST_CHECK(borderlineColorValue);
533 DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
535 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
536 DALI_TEST_CHECK(borderlineOffsetValue);
537 DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
539 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
540 DALI_TEST_CHECK(blurRadiusValue);
541 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
543 // change the blend color
544 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
545 colorVisual = factory.CreateVisual(propertyMap);
546 colorVisual.CreatePropertyMap(resultMap);
548 colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
549 DALI_TEST_CHECK(colorValue);
550 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
553 propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
555 colorVisual = factory.CreateVisual(propertyMap);
556 colorVisual.CreatePropertyMap(resultMap);
558 blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
559 DALI_TEST_CHECK(blurRadiusValue);
560 DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
565 int UtcDaliVisualGetPropertyMap2(void)
567 ToolkitTestApplication application;
568 tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
570 VisualFactory factory = VisualFactory::Get();
571 Property::Map propertyMap;
572 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
573 propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
574 propertyMap.Insert("borderColor", Color::BLUE);
575 propertyMap.Insert("borderSize", 5.f);
576 propertyMap.Insert("antiAliasing", true);
577 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
579 Property::Map resultMap;
580 borderVisual.CreatePropertyMap(resultMap);
582 // check the property values from the returned map from visual
583 Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
584 DALI_TEST_CHECK(typeValue);
585 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
587 Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
588 DALI_TEST_CHECK(colorValue);
589 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
591 Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
592 DALI_TEST_CHECK(sizeValue);
593 DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
595 Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
596 DALI_TEST_CHECK(AAValue);
597 DALI_TEST_CHECK(AAValue->Get<bool>() == true);
599 Property::Map propertyMap1;
600 propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
601 propertyMap1[BorderVisual::Property::COLOR] = Color::CYAN;
602 propertyMap1[BorderVisual::Property::SIZE] = 10.0f;
603 borderVisual = factory.CreateVisual(propertyMap1);
604 borderVisual.CreatePropertyMap(resultMap);
606 typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
607 DALI_TEST_CHECK(typeValue);
608 DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
610 colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
611 DALI_TEST_CHECK(colorValue);
612 DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
614 sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
615 DALI_TEST_CHECK(sizeValue);
616 DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
621 int UtcDaliVisualGetPropertyMap2N(void)
623 ToolkitTestApplication application;
624 tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
626 VisualFactory factory = VisualFactory::Get();
627 Property::Map propertyMap;
628 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
629 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
631 tet_infoline("Test that the visual is created, with a default renderer");
632 DALI_TEST_CHECK(borderVisual);
634 DummyControl dummyControl = DummyControl::New(true);
635 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
636 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
637 application.GetScene().Add(dummyControl);
639 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
644 int UtcDaliVisualGetPropertyMap3(void)
646 ToolkitTestApplication application;
647 tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
649 VisualFactory factory = VisualFactory::Get();
650 DALI_TEST_CHECK(factory);
652 Property::Map propertyMap;
653 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
655 Vector2 start(-1.f, -1.f);
656 Vector2 end(1.f, 1.f);
657 propertyMap.Insert("startPosition", start);
658 propertyMap.Insert("endPosition", end);
659 propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
661 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
663 Property::Array stopColors;
664 stopColors.PushBack(Color::RED);
665 stopColors.PushBack(Color::GREEN);
666 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
668 float borderlineWidth = 4.0f;
669 Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
670 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
671 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
673 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
675 Property::Map resultMap;
676 gradientVisual.CreatePropertyMap(resultMap);
678 // check the property values from the returned map from visual
679 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
680 DALI_TEST_CHECK(value);
681 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
683 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
684 DALI_TEST_CHECK(value);
685 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
687 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
688 DALI_TEST_CHECK(value);
689 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
691 value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
692 DALI_TEST_CHECK(value);
693 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
695 value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
696 DALI_TEST_CHECK(value);
697 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
699 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
700 DALI_TEST_CHECK(value);
701 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
703 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
704 DALI_TEST_CHECK(value);
705 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
707 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
708 DALI_TEST_CHECK(value);
709 Property::Array* offsetArray = value->GetArray();
710 DALI_TEST_CHECK(offsetArray->Count() == 2);
711 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
712 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
714 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
715 DALI_TEST_CHECK(value);
716 Property::Array* colorArray = value->GetArray();
717 DALI_TEST_CHECK(colorArray->Count() == 2);
718 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
719 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
724 int UtcDaliVisualGetPropertyMap4(void)
726 ToolkitTestApplication application;
727 tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
729 VisualFactory factory = VisualFactory::Get();
730 DALI_TEST_CHECK(factory);
732 Property::Map propertyMap;
733 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
735 Vector2 center(100.f, 100.f);
736 float radius = 100.f;
737 propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
738 propertyMap.Insert(GradientVisual::Property::CENTER, center);
739 propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
740 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
742 Property::Array stopColors;
743 stopColors.PushBack(Color::RED);
744 stopColors.PushBack(Color::BLACK);
745 stopColors.PushBack(Color::GREEN);
746 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
748 float borderlineWidth = 8.0f;
749 Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
750 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
751 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
753 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
754 DALI_TEST_CHECK(gradientVisual);
756 Property::Map resultMap;
757 gradientVisual.CreatePropertyMap(resultMap);
759 // check the property values from the returned map from visual
760 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
761 DALI_TEST_CHECK(value);
762 DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
764 value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
765 DALI_TEST_CHECK(value);
766 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
768 value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
769 DALI_TEST_CHECK(value);
770 DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
772 value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
773 DALI_TEST_CHECK(value);
774 DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
776 value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
777 DALI_TEST_CHECK(value);
778 DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
780 value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
781 DALI_TEST_CHECK(value);
782 DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
784 value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
785 DALI_TEST_CHECK(value);
786 DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
788 value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
789 DALI_TEST_CHECK(value);
790 Property::Array* offsetArray = value->GetArray();
791 DALI_TEST_CHECK(offsetArray->Count() == 3);
792 DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
793 DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
794 // any stop value will be clamped to [0.0, 1.0];
795 DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
797 value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
798 DALI_TEST_CHECK(value);
799 Property::Array* colorArray = value->GetArray();
800 DALI_TEST_CHECK(colorArray->Count() == 3);
801 DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
802 DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
803 DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
808 int UtcDaliVisualGetPropertyMap5(void)
810 ToolkitTestApplication application;
811 tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
813 VisualFactory factory = VisualFactory::Get();
814 Property::Map propertyMap;
815 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
816 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
817 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
818 propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
819 propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
820 propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
821 propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
822 propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
823 propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
824 propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
825 propertyMap.Insert("synchronousLoading", true);
827 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
828 DALI_TEST_CHECK(imageVisual);
830 Property::Map resultMap;
831 imageVisual.CreatePropertyMap(resultMap);
833 // check the property values from the returned map from visual
834 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
835 DALI_TEST_CHECK(value);
836 DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
838 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
839 DALI_TEST_CHECK(value);
840 DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
842 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
843 DALI_TEST_CHECK(value);
844 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
846 value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
847 DALI_TEST_CHECK(value);
848 DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
850 value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
851 DALI_TEST_CHECK(value);
852 DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
854 value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
855 DALI_TEST_CHECK(value);
856 DALI_TEST_CHECK(value->Get<int>() == 20);
858 value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
859 DALI_TEST_CHECK(value);
860 DALI_TEST_CHECK(value->Get<int>() == 30);
862 value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
863 DALI_TEST_CHECK(value);
864 DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
866 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
867 DALI_TEST_CHECK(value);
868 DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
870 value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
871 DALI_TEST_CHECK(value);
872 DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
874 value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
875 DALI_TEST_CHECK(value);
876 DALI_TEST_CHECK(value->Get<bool>() == true);
881 int UtcDaliVisualGetPropertyMap6(void)
883 ToolkitTestApplication application;
884 tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
886 Rect<int> border(1, 1, 1, 1);
888 VisualFactory factory = VisualFactory::Get();
889 Property::Map propertyMap;
890 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
891 propertyMap.Insert("mixColor", Color::MAGENTA);
892 propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
893 propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
894 propertyMap.Insert(ImageVisual::Property::BORDER, border);
895 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
896 propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
897 Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
899 Property::Map resultMap;
900 nPatchVisual.CreatePropertyMap(resultMap);
902 // check the property values from the returned map from visual
903 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
904 DALI_TEST_CHECK(value);
905 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
907 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
908 DALI_TEST_CHECK(value);
909 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
911 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
912 DALI_TEST_CHECK(value);
913 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
915 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
916 DALI_TEST_CHECK(value);
917 DALI_TEST_CHECK(value->Get<bool>());
919 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
920 DALI_TEST_CHECK(value);
921 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
923 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
924 DALI_TEST_CHECK(value);
925 DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
927 value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
928 DALI_TEST_CHECK(value);
929 DALI_TEST_CHECK(value->Get<float>() == 0.9f);
931 Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
933 Property::Map propertyMap1;
934 propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
935 propertyMap1.Insert("mixColor", Color::MAGENTA);
936 propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
937 propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
938 propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
939 nPatchVisual = factory.CreateVisual(propertyMap1);
941 nPatchVisual.CreatePropertyMap(resultMap);
943 // check the property values from the returned map from visual
944 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
945 DALI_TEST_CHECK(value);
946 DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
948 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
949 DALI_TEST_CHECK(value);
950 DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
952 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
953 DALI_TEST_CHECK(value);
954 DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
956 value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
957 DALI_TEST_CHECK(value);
958 DALI_TEST_CHECK(value->Get<bool>());
960 value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
961 DALI_TEST_CHECK(value);
962 DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
967 int UtcDaliVisualGetPropertyMap7(void)
969 ToolkitTestApplication application;
970 tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
972 // request SvgVisual with a property map
973 VisualFactory factory = VisualFactory::Get();
974 Property::Map propertyMap;
975 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
976 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
977 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
978 propertyMap.Insert(ImageVisual::Property::ATLASING, false);
979 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
981 Property::Map resultMap;
982 svgVisual.CreatePropertyMap(resultMap);
983 // check the property values from the returned map from a visual
984 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
985 DALI_TEST_CHECK(value);
986 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
988 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
989 DALI_TEST_CHECK(value);
990 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
992 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
993 DALI_TEST_CHECK(value);
994 DALI_TEST_CHECK(value->Get<bool>() == false);
996 // request SvgVisual with a property map 2
998 propertyMap["visualType"] = Visual::SVG;
999 propertyMap["mixColor"] = Color::WHITE;
1000 propertyMap["url"] = TEST_SVG_FILE_NAME;
1001 propertyMap["atlasing"] = true;
1002 Visual::Base svgVisual1 = factory.CreateVisual(propertyMap);
1005 svgVisual1.CreatePropertyMap(resultMap);
1006 // check the property values from the returned map from a visual
1007 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1008 DALI_TEST_CHECK(value);
1009 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1011 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1012 DALI_TEST_CHECK(value);
1013 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1015 value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1016 DALI_TEST_CHECK(value);
1017 DALI_TEST_CHECK(value->Get<bool>() == true);
1019 // request SvgVisual with an URL
1020 Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1022 svgVisual2.CreatePropertyMap(resultMap);
1023 // check the property values from the returned map from a visual
1024 value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1025 DALI_TEST_CHECK(value);
1026 DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1028 value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1029 DALI_TEST_CHECK(value);
1030 DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1036 int UtcDaliVisualGetPropertyMap8(void)
1038 ToolkitTestApplication application;
1039 tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1041 //Request MeshVisual using a property map.
1042 VisualFactory factory = VisualFactory::Get();
1043 Property::Map propertyMap;
1044 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1045 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1046 propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1047 propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1048 propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1049 propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1050 propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1051 Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1053 Property::Map resultMap;
1054 meshVisual.CreatePropertyMap(resultMap);
1055 TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1057 //Check values in the result map are identical to the initial map's values.
1058 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1059 DALI_TEST_CHECK(value);
1060 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1062 value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1063 DALI_TEST_CHECK(value);
1064 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1066 value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1067 DALI_TEST_CHECK(value);
1068 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1070 value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1071 DALI_TEST_CHECK(value);
1072 DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1074 value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1075 DALI_TEST_CHECK(value);
1076 DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1078 value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1079 DALI_TEST_CHECK(value);
1080 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1085 //Primitive shape visual
1086 int UtcDaliVisualGetPropertyMap9(void)
1088 ToolkitTestApplication application;
1089 tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1091 static std::vector<UniformData> customUniforms =
1093 UniformData("mixColor", Property::Type::VECTOR3),
1096 TestGraphicsController& graphics = application.GetGraphicsController();
1097 graphics.AddCustomUniforms(customUniforms);
1099 Vector4 color = Vector4(1.0, 0.8, 0.6, 1.0);
1100 Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1102 //Request PrimitiveVisual using a property map.
1103 VisualFactory factory = VisualFactory::Get();
1104 Property::Map propertyMap;
1105 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1106 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1107 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1108 propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1109 propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1110 propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1111 propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1112 propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1113 propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1114 propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1115 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1116 propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1117 propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1118 Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1120 Property::Map resultMap;
1121 primitiveVisual.CreatePropertyMap(resultMap);
1123 //Check values in the result map are identical to the initial map's values.
1124 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1125 DALI_TEST_CHECK(value);
1126 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1128 value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1129 DALI_TEST_CHECK(value);
1130 DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1132 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1133 DALI_TEST_CHECK(value);
1134 DALI_TEST_CHECK(value->Get<Vector4>() == color);
1135 DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1137 value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1138 DALI_TEST_CHECK(value);
1139 DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1141 value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1142 DALI_TEST_CHECK(value);
1143 DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1145 value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1146 DALI_TEST_CHECK(value);
1147 DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1149 value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1150 DALI_TEST_CHECK(value);
1151 DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1153 value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1154 DALI_TEST_CHECK(value);
1155 DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1157 value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1158 DALI_TEST_CHECK(value);
1159 DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1161 value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1162 DALI_TEST_CHECK(value);
1163 DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1165 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1166 DALI_TEST_CHECK(value);
1167 DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1169 value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1170 DALI_TEST_CHECK(value);
1171 DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1173 value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1174 DALI_TEST_CHECK(value);
1175 DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1177 DummyControl actor = DummyControl::New(true);
1178 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1179 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1180 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1181 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1182 application.GetScene().Add(actor);
1184 Animation animation = Animation::New(1.0f);
1185 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1187 application.SendNotification();
1188 application.Render(0);
1189 application.Render(1000);
1190 application.SendNotification();
1192 auto& gl = application.GetGlAbstraction();
1193 DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1195 tet_infoline("Check property map after animation");
1197 primitiveVisual.CreatePropertyMap(resultMap);
1198 value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1199 DALI_TEST_CHECK(value);
1200 color = value->Get<Vector4>();
1201 // Ignore alpha part
1202 DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1208 int UtcDaliVisualGetPropertyMap10(void)
1210 ToolkitTestApplication application;
1211 tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1213 //Request PrimitiveVisual using a property map.
1214 VisualFactory factory = VisualFactory::Get();
1216 Property::Map propertyMap;
1217 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1218 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1219 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1220 propertyMap.Insert("enableMarkup", false);
1221 propertyMap.Insert("text", "Hello world");
1222 propertyMap.Insert("fontFamily", "TizenSans");
1224 Property::Map fontStyleMapSet;
1225 fontStyleMapSet.Insert("weight", "bold");
1226 propertyMap.Insert("fontStyle", fontStyleMapSet);
1228 propertyMap.Insert("pointSize", 12.f);
1229 propertyMap.Insert("multiLine", true);
1230 propertyMap.Insert("horizontalAlignment", "CENTER");
1231 propertyMap.Insert("verticalAlignment", "CENTER");
1232 propertyMap.Insert("textColor", Color::RED);
1234 Property::Map shadowMapSet;
1235 propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1237 Property::Map underlineMapSet;
1238 propertyMap.Insert("underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1).Add("type", Text::Underline::Type::SOLID).Add("dashWidth", 2).Add("dashGap", 1));
1240 Property::Map outlineMapSet;
1241 propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1243 Property::Map backgroundMapSet;
1244 propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1246 Visual::Base textVisual = factory.CreateVisual(propertyMap);
1248 Property::Map resultMap;
1249 textVisual.CreatePropertyMap(resultMap);
1251 //Check values in the result map are identical to the initial map's values.
1252 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1253 DALI_TEST_CHECK(value);
1254 DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1256 value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1257 DALI_TEST_CHECK(value);
1258 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1260 value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1261 DALI_TEST_CHECK(value);
1262 DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1264 value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1265 DALI_TEST_CHECK(value);
1266 DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1268 value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1269 DALI_TEST_CHECK(value);
1271 Property::Map fontStyleMapGet = value->Get<Property::Map>();
1272 DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1273 DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1275 value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1276 DALI_TEST_CHECK(value);
1277 DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1279 value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1280 DALI_TEST_CHECK(value);
1281 DALI_TEST_CHECK(value->Get<bool>());
1283 value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1284 DALI_TEST_CHECK(value);
1285 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1287 value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1288 DALI_TEST_CHECK(value);
1289 DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1291 value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1292 DALI_TEST_CHECK(value);
1293 DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1295 value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1296 DALI_TEST_CHECK(value);
1297 DALI_TEST_CHECK(!value->Get<bool>());
1299 value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1300 DALI_TEST_CHECK(value);
1302 Property::Map shadowMapGet = value->Get<Property::Map>();
1303 DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1304 DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1306 value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1307 DALI_TEST_CHECK(value);
1309 Property::Map underlineMapGet = value->Get<Property::Map>();
1310 DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1311 DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1313 value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1314 DALI_TEST_CHECK(value);
1316 Property::Map outlineMapGet = value->Get<Property::Map>();
1317 DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1318 DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1320 value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1321 DALI_TEST_CHECK(value);
1323 Property::Map backgroundMapGet = value->Get<Property::Map>();
1324 DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1325 DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1330 int UtcDaliVisualGetPropertyMap11(void)
1332 ToolkitTestApplication application;
1333 tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1335 VisualFactory factory = VisualFactory::Get();
1336 DALI_TEST_CHECK(factory);
1338 Property::Map propertyMap;
1339 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1341 Vector2 start(-0.5f, 0.5f);
1342 Vector2 end(0.5f, -0.0f);
1343 Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1344 Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1345 Vector2 rotate_center(0.0f, 0.4f);
1346 float rotate_amount = 1.57f;
1347 float offset = 100.f;
1349 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1350 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1351 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1353 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1354 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1355 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1356 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1357 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1358 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1359 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1361 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1362 DALI_TEST_CHECK(animatedGradientVisual);
1364 Property::Map resultMap;
1365 animatedGradientVisual.CreatePropertyMap(resultMap);
1367 // check the property values from the returned map from visual
1368 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1369 DALI_TEST_CHECK(value);
1370 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1372 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1373 DALI_TEST_CHECK(value);
1374 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1376 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1377 DALI_TEST_CHECK(value);
1378 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1380 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1381 DALI_TEST_CHECK(value);
1382 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1384 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1385 DALI_TEST_CHECK(value);
1386 DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1388 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1389 DALI_TEST_CHECK(value);
1390 DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1392 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1393 DALI_TEST_CHECK(value);
1394 DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1396 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1397 DALI_TEST_CHECK(value);
1398 DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1400 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1401 DALI_TEST_CHECK(value);
1402 DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1404 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1405 DALI_TEST_CHECK(value);
1406 DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1408 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1409 DALI_TEST_CHECK(value);
1410 DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1415 int UtcDaliVisualGetPropertyMap12(void)
1417 ToolkitTestApplication application;
1418 tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1420 // Case 1 : Set values by index
1422 tet_printf(" - Set Values by Index\n");
1423 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1424 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1425 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1427 tet_printf("test with delay [%f]\n", _delay);
1428 VisualFactory factory = VisualFactory::Get();
1429 DALI_TEST_CHECK(factory);
1431 Property::Map propertyMap;
1432 Property::Map animationMap;
1433 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1435 float duration = 1.1f;
1436 float delay = _delay;
1437 float repeat_delay = 0.4f;
1439 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1441 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1442 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1444 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1445 animationMap.Clear();
1446 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1447 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1448 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1449 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1450 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1451 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1452 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1453 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1454 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1456 return animationMap;
1459 Vector2 start1(-0.5f, 0.5f);
1460 Vector2 end1(0.5f, -0.5f);
1461 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1462 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1463 Vector2 rotate_center1(0.0f, 0.4f);
1464 float rotate_amount1 = 0.0f;
1465 float offset1 = 0.f;
1467 Vector2 start2(-0.5f, -0.5f);
1468 Vector2 end2(0.5f, 0.5f);
1469 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1470 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1471 Vector2 rotate_center2(0.0f, -0.4f);
1472 float rotate_amount2 = 6.2832f;
1473 float offset2 = 2.f;
1475 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1476 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1477 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1479 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1480 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1481 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1482 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1483 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1484 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1485 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1487 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1488 DALI_TEST_CHECK(animatedGradientVisual);
1490 Property::Map resultMap;
1491 animatedGradientVisual.CreatePropertyMap(resultMap);
1493 // check the property values from the returned map from visual
1494 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1495 DALI_TEST_CHECK(value);
1496 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1498 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1499 DALI_TEST_CHECK(value);
1500 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1502 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1503 DALI_TEST_CHECK(value);
1504 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1506 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1507 DALI_TEST_CHECK(value);
1508 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1510 auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1511 tet_printf("Check value at %d\n", line_num);
1512 value = resultMap.Find(index, Property::MAP);
1513 DALI_TEST_CHECK(value);
1514 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1515 Property::Map* temp_map = value->GetMap();
1516 DALI_TEST_CHECK(temp_map);
1518 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1519 Property::Value* res = temp_map->Find(index);
1520 DALI_TEST_CHECK(res);
1524 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1525 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1526 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1527 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1528 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1529 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1530 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1531 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1532 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1535 // check the animation map data is good
1536 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1537 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1538 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1539 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1540 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1541 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1542 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1546 // Case 2 : Set values by string
1548 tet_printf(" - Set Values by String\n");
1549 // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1550 // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1551 for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1553 tet_printf("test with delay [%f]\n", _delay);
1554 VisualFactory factory = VisualFactory::Get();
1555 DALI_TEST_CHECK(factory);
1557 Property::Map propertyMap;
1558 Property::Map animationMap;
1559 propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1561 float duration = 1.1f;
1562 float delay = _delay;
1563 float repeat_delay = 0.4f;
1565 int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1567 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1568 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1570 auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1571 animationMap.Clear();
1572 animationMap.Insert("startValue", start);
1573 animationMap.Insert("targetValue", target);
1574 animationMap.Insert("directionType", "BACKWARD");
1575 animationMap.Insert("duration", duration);
1576 animationMap.Insert("delay", delay);
1577 animationMap.Insert("repeat", loop_count);
1578 animationMap.Insert("repeatDelay", repeat_delay);
1579 animationMap.Insert("motionType", "MIRROR");
1580 animationMap.Insert("easingType", "IN_OUT");
1582 return animationMap;
1585 Vector2 start1(-0.5f, 0.5f);
1586 Vector2 end1(0.5f, -0.5f);
1587 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1588 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1589 Vector2 rotate_center1(0.0f, 0.4f);
1590 float rotate_amount1 = 0.0f;
1591 float offset1 = 0.f;
1593 Vector2 start2(-0.5f, -0.5f);
1594 Vector2 end2(0.5f, 0.5f);
1595 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1596 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1597 Vector2 rotate_center2(0.0f, -0.4f);
1598 float rotate_amount2 = 6.2832f;
1599 float offset2 = 2.f;
1601 // For test mix the type string/index key and string/index value works well.
1602 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1603 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1604 propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1606 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1607 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1608 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1609 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1610 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1611 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1612 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1614 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1615 DALI_TEST_CHECK(animatedGradientVisual);
1617 Property::Map resultMap;
1618 animatedGradientVisual.CreatePropertyMap(resultMap);
1620 // check the property values from the returned map from visual
1621 // Note : resultMap from CreatePropertyMap only contain indexKey
1622 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1623 DALI_TEST_CHECK(value);
1624 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1626 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1627 DALI_TEST_CHECK(value);
1628 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1630 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1631 DALI_TEST_CHECK(value);
1632 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1634 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1635 DALI_TEST_CHECK(value);
1636 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1638 auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1639 tet_printf("Check value at %d\n", line_num);
1640 value = resultMap.Find(index, Property::MAP);
1641 DALI_TEST_CHECK(value);
1642 DALI_TEST_CHECK(value->GetType() == Property::MAP);
1643 Property::Map* temp_map = value->GetMap();
1644 DALI_TEST_CHECK(temp_map);
1646 auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1647 Property::Value* res = temp_map->Find(index);
1648 DALI_TEST_CHECK(res);
1652 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1653 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1654 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1655 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1656 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1657 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1658 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1659 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1660 DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1663 // check the animation map data is good
1664 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1665 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1666 checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1667 checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1668 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1669 checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1670 checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1676 int UtcDaliVisualGetPropertyMap13(void)
1678 ToolkitTestApplication application;
1679 tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1681 for(int _direction = 0; _direction <= 1; ++_direction)
1683 for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1685 tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1686 VisualFactory factory = VisualFactory::Get();
1687 DALI_TEST_CHECK(factory);
1689 Property::Map propertyMap;
1690 Property::Map animationMap;
1691 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1693 float duration = 1.0f;
1694 float delay = _delay;
1695 float repeat_delay = 0.5f;
1697 int direction = _direction;
1698 int loop_count = 0; // When loop_count is 0, Animation will not be created.
1699 int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1700 int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1702 auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1703 animationMap.Clear();
1704 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1705 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1707 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1709 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1710 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1711 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1712 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1713 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1714 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1715 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1716 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1718 return animationMap;
1721 Vector2 start1(-0.5f, 0.5f);
1722 Vector2 end1(0.5f, -0.5f);
1723 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1724 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1725 Vector2 rotate_center1(1.0f, 0.4f);
1726 float rotate_amount1 = 2.0f;
1727 float offset1 = 1.f;
1729 Vector2 start2(-0.5f, -0.5f);
1730 Vector2 end2(0.5f, 0.5f);
1731 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1732 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1733 Vector2 rotate_center2(1.0f, -0.4f);
1734 float rotate_amount2 = 1.0f;
1735 float offset2 = 3.f;
1737 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1738 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1739 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1741 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1742 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1743 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1744 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1745 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1746 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1747 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1749 Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1750 DALI_TEST_CHECK(animatedGradientVisual);
1752 Property::Map resultMap;
1753 animatedGradientVisual.CreatePropertyMap(resultMap);
1755 // check the property values from the returned map from visual
1756 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1757 DALI_TEST_CHECK(value);
1758 DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1760 value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1761 DALI_TEST_CHECK(value);
1762 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1764 value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1765 DALI_TEST_CHECK(value);
1766 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1768 value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1769 DALI_TEST_CHECK(value);
1770 DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1772 // If loop_count = 0, Animation doesn't created.
1773 // Optimized resultMap only have one value, which is target value
1774 // Note: target value will be changed by direction option.
1775 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1776 DALI_TEST_CHECK(value);
1777 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1779 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1780 DALI_TEST_CHECK(value);
1781 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1783 value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1784 DALI_TEST_CHECK(value);
1785 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1787 value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1788 DALI_TEST_CHECK(value);
1789 DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1791 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1792 DALI_TEST_CHECK(value);
1793 DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1795 value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1796 DALI_TEST_CHECK(value);
1797 DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1799 value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1800 DALI_TEST_CHECK(value);
1801 DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1808 int UtcDaliVisualAnimateBorderVisual01(void)
1810 ToolkitTestApplication application;
1811 tet_infoline("UtcDaliAnimateBorderVisual Color");
1813 static std::vector<UniformData> customUniforms =
1815 UniformData("borderColor", Property::Type::VECTOR4),
1816 UniformData("mixColor", Property::Type::VECTOR3),
1819 TestGraphicsController& graphics = application.GetGraphicsController();
1820 graphics.AddCustomUniforms(customUniforms);
1822 VisualFactory factory = VisualFactory::Get();
1823 Property::Map propertyMap;
1824 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1825 propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1826 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1827 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1828 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1831 map["target"] = "testVisual";
1832 map["property"] = "mixColor";
1833 map["targetValue"] = Vector4(1, 1, 1, 0.1);
1834 map["animator"] = Property::Map()
1835 .Add("alphaFunction", "LINEAR")
1836 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1838 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1840 DummyControl actor = DummyControl::New(true);
1841 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1842 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1843 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1844 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1845 application.GetScene().Add(actor);
1847 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1849 Renderer renderer = actor.GetRendererAt(0);
1850 Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1851 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1853 Animation animation = dummyImpl.CreateTransition(transition);
1855 // Animate the mix color through the transition, and the border color through
1856 // programmatic method.
1857 animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1860 application.SendNotification();
1861 application.Render(0);
1862 application.Render(2000u); // halfway point between blue and white
1864 Vector4 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1865 Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1866 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1867 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1869 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1870 testColor = Vector4(1, 1, 1, 0.45f);
1871 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1872 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1875 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1876 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1878 application.Render(2000u);
1880 color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1881 DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1882 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1884 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1885 testColor = Vector4(1, 1, 1, 0.1);
1886 DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1887 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1889 DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1890 DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1895 int UtcDaliVisualAnimateBorderVisual02(void)
1897 ToolkitTestApplication application;
1898 tet_infoline("UtcDaliAnimateBorderVisual Size");
1900 static std::vector<UniformData> customUniforms =
1902 UniformData("borderSize", Property::Type::FLOAT),
1905 TestGraphicsController& graphics = application.GetGraphicsController();
1906 graphics.AddCustomUniforms(customUniforms);
1908 VisualFactory factory = VisualFactory::Get();
1909 Property::Map propertyMap;
1910 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1911 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1912 propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1913 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1915 DummyControl actor = DummyControl::New(true);
1916 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1917 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1918 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1919 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1920 application.GetScene().Add(actor);
1922 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1924 Renderer renderer = actor.GetRendererAt(0);
1925 Property::Index index = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1927 Animation animation = Animation::New(4.0f);
1928 animation.AnimateTo(Property(renderer, index), 9.0f);
1931 application.SendNotification();
1932 application.Render(0);
1933 application.Render(2000u); // halfway point
1935 float size = renderer.GetCurrentProperty<float>(index);
1936 DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1937 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1939 application.Render(2000u); // halfway point between blue and white
1941 size = renderer.GetCurrentProperty<float>(index);
1942 DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1943 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1948 int UtcDaliVisualAnimateColorVisual(void)
1950 ToolkitTestApplication application;
1951 tet_infoline("UtcDaliAnimateColorVisual mixColor");
1953 static std::vector<UniformData> customUniforms =
1955 UniformData("mixColor", Property::Type::VECTOR3),
1958 TestGraphicsController& graphics = application.GetGraphicsController();
1959 graphics.AddCustomUniforms(customUniforms);
1961 VisualFactory factory = VisualFactory::Get();
1962 Property::Map propertyMap;
1963 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1964 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1965 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1967 DummyControl actor = DummyControl::New(true);
1968 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1969 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1970 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1971 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1972 application.GetScene().Add(actor);
1974 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1976 Renderer renderer = actor.GetRendererAt(0);
1977 Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1979 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1980 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1982 Animation animation = Animation::New(4.0f);
1983 animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1986 application.SendNotification();
1987 application.Render(0);
1988 application.Render(2000u); // halfway point
1990 Vector3 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1991 Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
1992 DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1994 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1996 application.Render(2000u); // halfway point between blue and white
1998 color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1999 DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2001 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2003 blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2004 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2009 int UtcDaliVisualAnimatePrimitiveVisual(void)
2011 ToolkitTestApplication application;
2012 tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2014 static std::vector<UniformData> customUniforms =
2016 UniformData("mixColor", Property::Type::VECTOR3),
2019 TestGraphicsController& graphics = application.GetGraphicsController();
2020 graphics.AddCustomUniforms(customUniforms);
2023 VisualFactory factory = VisualFactory::Get();
2024 Property::Map propertyMap;
2025 propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2026 propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2027 propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2028 Visual::Base visual = factory.CreateVisual(propertyMap);
2030 DummyControl actor = DummyControl::New(true);
2031 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2032 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2033 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2034 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2035 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2036 application.GetScene().Add(actor);
2038 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2040 Renderer renderer = actor.GetRendererAt(0);
2042 const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2043 const Vector4 TARGET_MIX_COLOR(Color::RED);
2046 map["target"] = "testVisual";
2047 map["property"] = "mixColor";
2048 map["initialValue"] = INITIAL_MIX_COLOR;
2049 map["targetValue"] = TARGET_MIX_COLOR;
2050 map["animator"] = Property::Map()
2051 .Add("alphaFunction", "LINEAR")
2052 .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2054 Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2056 Animation animation = dummyImpl.CreateTransition(transition);
2057 animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2060 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2061 glAbstraction.EnableEnableDisableCallTrace(true);
2062 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2063 std::ostringstream blendStr;
2064 blendStr << std::hex << GL_BLEND;
2066 application.SendNotification();
2067 application.Render(0);
2068 application.Render(2000u); // halfway point
2069 application.SendNotification();
2071 Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2072 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2073 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2075 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2077 glEnableStack.Reset();
2079 application.Render(2001u); // go past end
2080 application.SendNotification(); // Trigger signals
2082 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2083 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2084 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2086 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2094 int UtcDaliVisualAnimatedGradientVisual01(void)
2096 ToolkitTestApplication application;
2097 tet_infoline("UtcDaliAnimatedGradientVisual with default");
2099 static std::vector<UniformData> customUniforms =
2101 UniformData("start_point", Property::Type::VECTOR2),
2102 UniformData("end_point", Property::Type::VECTOR2),
2103 UniformData("start_color", Property::Type::VECTOR4),
2104 UniformData("end_color", Property::Type::VECTOR4),
2105 UniformData("rotate_center", Property::Type::VECTOR2),
2106 UniformData("rotate_angle", Property::Type::FLOAT),
2107 UniformData("gradient_offset", Property::Type::FLOAT),
2110 TestGraphicsController& graphics = application.GetGraphicsController();
2111 graphics.AddCustomUniforms(customUniforms);
2114 VisualFactory factory = VisualFactory::Get();
2115 Property::Map propertyMap;
2116 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2117 Visual::Base visual = factory.CreateVisual(propertyMap);
2119 DummyControl actor = DummyControl::New(true);
2120 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2121 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2122 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2123 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2124 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2125 application.GetScene().Add(actor);
2127 application.SendNotification();
2128 application.Render(0);
2129 application.SendNotification();
2131 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2133 for(int step_iter = 0; step_iter < 3; step_iter++)
2135 application.SendNotification();
2136 application.Render(0);
2137 application.Render(750u); // step i/4
2138 application.SendNotification();
2140 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2141 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2142 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2143 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2144 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2145 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2146 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2149 //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2150 application.Render(750u); // go to end
2151 application.SendNotification();
2153 application.Render(10u); // finish
2154 application.SendNotification();
2157 application.SendNotification();
2158 application.Render(0u);
2159 application.SendNotification();
2165 int UtcDaliVisualAnimatedGradientVisual02(void)
2167 ToolkitTestApplication application;
2168 tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2170 static std::vector<UniformData> customUniforms =
2172 UniformData("start_point", Property::Type::VECTOR2),
2173 UniformData("end_point", Property::Type::VECTOR2),
2174 UniformData("start_color", Property::Type::VECTOR4),
2175 UniformData("end_color", Property::Type::VECTOR4),
2176 UniformData("rotate_center", Property::Type::VECTOR2),
2177 UniformData("rotate_angle", Property::Type::FLOAT),
2178 UniformData("gradient_offset", Property::Type::FLOAT),
2181 TestGraphicsController& graphics = application.GetGraphicsController();
2182 graphics.AddCustomUniforms(customUniforms);
2185 float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2186 int _direction[2] = {0, 1};
2187 int _loop_count[3] = {-1, 0, 1};
2188 int _motion[2] = {0, 1};
2189 int _easing[4] = {0, 1, 2, 3};
2191 int test_case_max = 4 * 2 * 3 * 2 * 4;
2193 int test_case_d = 7; // 7 is the number of animated properties.
2195 float _duration = 0.4f;
2196 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2197 float noise_maker = 0.0f;
2198 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2199 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2201 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2203 VisualFactory factory = VisualFactory::Get();
2204 Property::Map propertyMap;
2205 Property::Map animationMap;
2206 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2208 int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2209 int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2210 int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2212 auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2213 int tc = (test_case + tc_offset);
2214 int idx_easing = tc % 4;
2216 int idx_motion = tc % 2;
2218 int idx_loop_count = tc % 3;
2220 int idx_direction = tc % 2;
2222 int idx_delay = tc % 4;
2225 float duration = _duration - _repeat_delay;
2226 float repeat_delay = _repeat_delay;
2227 float delay = _delay[idx_delay] * _duration;
2228 int direction = _direction[idx_direction];
2229 int loop_count = _loop_count[idx_loop_count];
2230 int motion = _motion[idx_motion];
2231 int easing = _easing[idx_easing];
2233 animationMap.Clear();
2234 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2235 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2238 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2242 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2244 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2245 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2246 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2247 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2250 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2254 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2258 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2260 else if(easing == 1)
2262 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2264 else if(easing == 2)
2266 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2270 animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2273 return animationMap;
2276 // Give different values for debuging
2277 noise_maker += 1.0f;
2278 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2279 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2280 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2281 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2282 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2283 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2284 float offset1 = 0.f + noise_maker * 0.1f;
2286 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2287 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2288 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2289 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2290 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2291 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2292 float offset2 = 2.f + noise_maker * 0.1f;
2294 propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2295 propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2296 propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2298 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2299 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2300 propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2301 propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2302 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2303 propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2304 propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2306 Visual::Base visual = factory.CreateVisual(propertyMap);
2308 DummyControl actor = DummyControl::New(true);
2309 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2310 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2311 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2312 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2313 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2314 application.GetScene().Add(actor);
2316 application.SendNotification();
2317 application.Render(0);
2318 application.SendNotification();
2320 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2322 application.SendNotification();
2324 //Compare between CPU calculated value and Shader Visual calculated value
2325 auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2326 int tc = (test_case + tc_offset);
2327 int idx_easing = tc % 4;
2329 int idx_motion = tc % 2;
2331 int idx_loop_count = tc % 3;
2333 int idx_direction = tc % 2;
2335 int idx_delay = tc % 4;
2338 float duration = _duration - _repeat_delay;
2339 float repeat_delay = _repeat_delay;
2340 float delay = _delay[idx_delay] * _duration;
2341 int direction = _direction[idx_direction];
2342 int loop_count = _loop_count[idx_loop_count];
2343 int motion = _motion[idx_motion];
2344 int easing = _easing[idx_easing];
2346 progress -= delay / _duration;
2348 Property::Value s = start;
2349 Property::Value t = target;
2355 float x; ///< Animator progress value
2360 else if(loop_count > 0 && progress + 0.01f > loop_count)
2362 x = (motion == 0) ? 1.0f : 0.0f;
2370 progress = fmodf(progress, 1.0f);
2371 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2376 x = progress * 2.0f;
2383 if(easing == 1) // EASE_IN
2387 else if(easing == 2) // EASE_OUT
2389 x = 2.0f * x - x * x;
2391 else if(easing == 3) // EASE_IN_OUT
2393 x = x * x * (3.0f - 2.0f * x);
2396 if(value_type == 0) // result type is Float
2400 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2401 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2402 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2404 else if(value_type == 1) // result type is Vector2
2408 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2409 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2410 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2412 else if(value_type == 2) // result type is Vector3
2416 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2417 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2418 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2420 else // result type is Vector4
2424 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2425 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2426 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2431 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2433 for(int step_iter = 0; step_iter < 3; step_iter++)
2435 application.SendNotification();
2436 application.Render(_duration * 250.f); // step i/4
2437 application.SendNotification();
2440 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2441 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2442 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2443 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2444 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2445 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2446 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2448 application.SendNotification();
2449 application.Render(_duration * 250.f); // step 4/4 will not test
2450 application.SendNotification();
2454 application.SendNotification();
2456 application.SendNotification();
2457 application.Render(10.f); // tempral time
2458 application.SendNotification();
2465 int UtcDaliVisualAnimatedGradientVisual03(void)
2467 ToolkitTestApplication application;
2468 tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2470 static std::vector<UniformData> customUniforms =
2472 UniformData("start_point", Property::Type::VECTOR2),
2473 UniformData("end_point", Property::Type::VECTOR2),
2474 UniformData("start_color", Property::Type::VECTOR4),
2475 UniformData("end_color", Property::Type::VECTOR4),
2476 UniformData("rotate_center", Property::Type::VECTOR2),
2477 UniformData("rotate_angle", Property::Type::FLOAT),
2478 UniformData("gradient_offset", Property::Type::FLOAT),
2481 TestGraphicsController& graphics = application.GetGraphicsController();
2482 graphics.AddCustomUniforms(customUniforms);
2485 float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2486 int _direction[2] = {0, 1};
2487 int _loop_count[3] = {-1, 0, 1};
2488 int _motion[2] = {0, 1};
2489 int _easing[4] = {0, 1, 2, 3};
2491 int test_case_max = 4 * 2 * 3 * 2 * 4;
2493 int test_case_d = 7; // 7 is the number of animated properties.
2495 float _duration = 0.4f;
2496 float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2497 float noise_maker = 0.2f;
2498 // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2499 for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2501 tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2503 VisualFactory factory = VisualFactory::Get();
2504 Property::Map propertyMap;
2505 Property::Map animationMap;
2506 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2508 auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2509 int tc = (test_case + tc_offset);
2510 int idx_easing = tc % 4;
2512 int idx_motion = tc % 2;
2514 int idx_loop_count = tc % 3;
2516 int idx_direction = tc % 2;
2518 int idx_delay = tc % 4;
2521 float duration = _duration - _repeat_delay;
2522 float repeat_delay = _repeat_delay;
2523 float delay = _delay[idx_delay] * _duration;
2524 int direction = _direction[idx_direction];
2525 int loop_count = _loop_count[idx_loop_count];
2526 int motion = _motion[idx_motion];
2527 int easing = _easing[idx_easing];
2529 animationMap.Clear();
2530 animationMap.Insert("startValue", start);
2531 animationMap.Insert("targetValue", target);
2534 animationMap.Insert("directionType", "FORWARD");
2538 animationMap.Insert("directionType", "BACKWARD");
2540 animationMap.Insert("duration", duration);
2541 animationMap.Insert("delay", delay);
2542 animationMap.Insert("repeat", loop_count);
2543 animationMap.Insert("repeatDelay", repeat_delay);
2546 animationMap.Insert("motionType", "LOOP");
2550 animationMap.Insert("motionType", "MIRROR");
2554 animationMap.Insert("easingType", "LINEAR");
2556 else if(easing == 1)
2558 animationMap.Insert("easingType", "IN");
2560 else if(easing == 2)
2562 animationMap.Insert("easingType", "OUT");
2566 animationMap.Insert("easingType", "IN_OUT");
2569 return animationMap;
2572 // Give different values for debuging
2573 noise_maker += 0.8f;
2574 Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2575 Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2576 Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2577 Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2578 Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2579 float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2580 float offset1 = 0.f + noise_maker * 0.1f;
2582 Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2583 Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2584 Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2585 Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2586 Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2587 float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2588 float offset2 = 2.f + noise_maker * 0.1f;
2590 propertyMap.Insert("gradientType", "LINEAR");
2591 propertyMap.Insert("unitType", "USER_SPACE");
2592 propertyMap.Insert("spreadType", "CLAMP");
2594 propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2595 propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2596 propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2597 propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2598 propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2599 propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2600 propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2602 Visual::Base visual = factory.CreateVisual(propertyMap);
2604 DummyControl actor = DummyControl::New(true);
2605 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2606 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2607 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2608 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2609 actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2610 application.GetScene().Add(actor);
2612 application.SendNotification();
2613 application.Render(0);
2614 application.SendNotification();
2616 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2618 application.SendNotification();
2620 //Compare between CPU calculated value and Shader Visual calculated value
2621 auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2622 int tc = (test_case + tc_offset);
2623 int idx_easing = tc % 4;
2625 int idx_motion = tc % 2;
2627 int idx_loop_count = tc % 3;
2629 int idx_direction = tc % 2;
2631 int idx_delay = tc % 4;
2634 float duration = _duration - _repeat_delay;
2635 float repeat_delay = _repeat_delay;
2636 float delay = _delay[idx_delay] * _duration;
2637 int direction = _direction[idx_direction];
2638 int loop_count = _loop_count[idx_loop_count];
2639 int motion = _motion[idx_motion];
2640 int easing = _easing[idx_easing];
2642 progress -= delay / _duration;
2644 Property::Value s = start;
2645 Property::Value t = target;
2651 float x; ///< Animator progress value
2656 else if(loop_count > 0 && progress + 0.01f > loop_count)
2658 x = (motion == 0) ? 1.0f : 0.0f;
2666 progress = fmodf(progress, 1.0f);
2667 progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2672 x = progress * 2.0f;
2679 if(easing == 1) // EASE_IN
2683 else if(easing == 2) // EASE_OUT
2685 x = 2.0f * x - x * x;
2687 else if(easing == 3) // EASE_IN_OUT
2689 x = x * x * (3.0f - 2.0f * x);
2692 if(value_type == 0) // result type is Float
2696 res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2697 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2698 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2700 else if(value_type == 1) // result type is Vector2
2704 res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2705 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2706 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2708 else if(value_type == 2) // result type is Vector3
2712 res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2713 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2714 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2716 else // result type is Vector4
2720 res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2721 DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2722 DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2727 for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2729 for(int step_iter = 0; step_iter < 3; step_iter++)
2731 application.SendNotification();
2732 application.Render(_duration * 250.f); // step i/4
2733 application.SendNotification();
2736 testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2737 testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2738 testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2739 testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2740 testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2741 testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2742 testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2744 application.SendNotification();
2745 application.Render(_duration * 250.f); // step 4/4 will not test
2746 application.SendNotification();
2750 application.SendNotification();
2752 application.SendNotification();
2753 application.Render(10.f); // tempral time
2754 application.SendNotification();
2761 int UtcDaliVisualWireframeVisual(void)
2763 ToolkitTestApplication application;
2765 VisualFactory factory = VisualFactory::Get();
2766 Property::Map propertyMap;
2767 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2769 // Create the visual.
2770 Visual::Base visual = factory.CreateVisual(propertyMap);
2772 DALI_TEST_CHECK(visual);
2774 Property::Map resultMap;
2775 visual.CreatePropertyMap(resultMap);
2777 // Check the property values from the returned map from visual
2778 Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2779 DALI_TEST_CHECK(value);
2780 DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2785 int UtcDaliVisualGetTransform(void)
2787 ToolkitTestApplication application;
2788 tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2790 VisualFactory factory = VisualFactory::Get();
2791 Property::Map propertyMap;
2792 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2793 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2794 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2796 Dali::Property::Map visualMap;
2797 colorVisual.CreatePropertyMap(visualMap);
2798 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2799 Dali::Property::Map* map = value->GetMap();
2800 DALI_TEST_CHECK(map);
2802 //Test default values
2804 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2805 DALI_TEST_CHECK(typeValue);
2806 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2809 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2810 DALI_TEST_CHECK(typeValue);
2811 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2814 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2815 DALI_TEST_CHECK(typeValue);
2816 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2819 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2820 DALI_TEST_CHECK(typeValue);
2821 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2824 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2825 DALI_TEST_CHECK(typeValue);
2826 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2829 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2830 DALI_TEST_CHECK(typeValue);
2831 DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2834 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2835 DALI_TEST_CHECK(typeValue);
2836 DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2842 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2844 Property::Map transform;
2845 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2846 transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2847 transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2848 transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2849 transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2850 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2852 visual.SetTransformAndSize(transform, Vector2(100, 100));
2854 Dali::Property::Map visualMap;
2855 visual.CreatePropertyMap(visualMap);
2856 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2857 Dali::Property::Map* map = value->GetMap();
2858 DALI_TEST_CHECK(map);
2861 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2862 DALI_TEST_CHECK(typeValue);
2863 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2866 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2867 DALI_TEST_CHECK(typeValue);
2868 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2871 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2872 DALI_TEST_CHECK(typeValue);
2873 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2876 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2877 DALI_TEST_CHECK(typeValue);
2878 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2881 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2882 DALI_TEST_CHECK(typeValue);
2883 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2886 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2887 DALI_TEST_CHECK(typeValue);
2888 DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2891 Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2892 DALI_TEST_CHECK(typeValue);
2893 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2896 //Put the visual on the stage
2897 DummyControl actor = DummyControl::New(true);
2898 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2899 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2900 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2901 application.GetScene().Add(actor);
2903 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2904 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2906 application.SendNotification();
2907 application.Render(0);
2908 Renderer renderer(actor.GetRendererAt(0));
2910 Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2911 DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2913 Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2914 DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2916 Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2917 DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2919 Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2920 DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2922 Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2923 DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2925 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2926 DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2928 //Set a new transform
2930 transform = DefaultTransform();
2931 transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2932 transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2933 transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2934 transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2935 visual.SetTransformAndSize(transform, Vector2(100, 100));
2936 application.SendNotification();
2937 application.Render(0);
2939 //Check that the values have changed in the renderer
2940 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2941 DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2943 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2944 DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2946 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2947 DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2949 //Parent origin and anchor point should have the default values
2950 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2951 DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2953 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2954 DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2956 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2957 DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2960 int UtcDaliVisualSetTransform01(void)
2962 ToolkitTestApplication application;
2963 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2965 VisualFactory factory = VisualFactory::Get();
2966 Property::Map propertyMap;
2967 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2968 propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2969 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2970 Visual::Base visual = factory.CreateVisual(propertyMap);
2971 TestTransform(application, visual);
2972 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2977 int UtcDaliVisualSetTransform0(void)
2979 ToolkitTestApplication application;
2980 tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2982 VisualFactory factory = VisualFactory::Get();
2983 Property::Map propertyMap;
2984 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2985 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2986 Visual::Base visual = factory.CreateVisual(propertyMap);
2987 TestTransform(application, visual);
2988 TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2993 int UtcDaliVisualSetTransform1(void)
2995 ToolkitTestApplication application;
2996 tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
2998 VisualFactory factory = VisualFactory::Get();
2999 Property::Map propertyMap;
3000 propertyMap[Toolkit::Visual::Property::TYPE] = Visual::PRIMITIVE;
3001 propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3002 propertyMap[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::SPHERE;
3003 propertyMap[PrimitiveVisual::Property::SLICES] = 10;
3004 propertyMap[PrimitiveVisual::Property::STACKS] = 10;
3005 Visual::Base visual = factory.CreateVisual(propertyMap);
3006 TestTransform(application, visual);
3007 TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3012 int UtcDaliVisualSetTransform2(void)
3014 ToolkitTestApplication application;
3015 tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3017 VisualFactory factory = VisualFactory::Get();
3018 Property::Map propertyMap;
3019 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3020 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3022 Property::Array stopOffsets;
3023 stopOffsets.PushBack(0.0f);
3024 stopOffsets.PushBack(0.3f);
3025 stopOffsets.PushBack(0.6f);
3026 stopOffsets.PushBack(0.8f);
3027 stopOffsets.PushBack(1.0f);
3028 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3030 Property::Array stopColors;
3031 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3032 stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3033 stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3034 stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3035 stopColors.PushBack(Color::YELLOW);
3036 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3037 propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3038 propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3039 Visual::Base visual = factory.CreateVisual(propertyMap);
3040 TestTransform(application, visual);
3041 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3046 int UtcDaliVisualSetTransform3(void)
3048 ToolkitTestApplication application;
3049 tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3051 VisualFactory factory = VisualFactory::Get();
3052 Property::Map propertyMap;
3053 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3054 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3055 propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3056 propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3057 Visual::Base visual = factory.CreateVisual(propertyMap);
3058 TestTransform(application, visual);
3059 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3064 int UtcDaliVisualSetTransform4(void)
3066 ToolkitTestApplication application;
3067 tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3069 VisualFactory factory = VisualFactory::Get();
3070 Property::Map propertyMap;
3071 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3072 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3074 propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3075 propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3076 propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3077 propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3078 propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3079 Visual::Base visual = factory.CreateVisual(propertyMap);
3080 TestTransform(application, visual);
3081 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3086 int UtcDaliVisualSetTransform5(void)
3088 ToolkitTestApplication application;
3089 tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3091 VisualFactory factory = VisualFactory::Get();
3092 Property::Map propertyMap;
3093 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3094 propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3095 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3096 propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3097 propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3098 propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3099 propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3100 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3101 Visual::Base visual = factory.CreateVisual(propertyMap);
3102 TestTransform(application, visual);
3103 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3108 int UtcDaliVisualSetTransform6(void)
3110 ToolkitTestApplication application;
3111 tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3113 VisualFactory factory = VisualFactory::Get();
3114 Property::Map propertyMap;
3115 propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3116 propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3117 propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3118 Visual::Base visual = factory.CreateVisual(propertyMap);
3119 TestTransform(application, visual);
3120 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3125 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3127 ToolkitTestApplication application;
3128 tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3130 VisualFactory factory = VisualFactory::Get();
3131 Property::Map propertyMap;
3132 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3133 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3134 Visual::Base visual = factory.CreateVisual(propertyMap);
3136 Property::Map transform;
3137 transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3138 transform["sizePolicy"] = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3139 visual.SetTransformAndSize(transform, Vector2(100, 100));
3141 Dali::Property::Map visualMap;
3142 visual.CreatePropertyMap(visualMap);
3143 Property::Value* value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3144 Dali::Property::Map* map = value->GetMap();
3145 DALI_TEST_CHECK(map);
3148 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3149 DALI_TEST_CHECK(typeValue);
3150 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3153 Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3154 DALI_TEST_CHECK(typeValue);
3155 DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3161 int UtcDaliNPatchVisualCustomShader(void)
3163 ToolkitTestApplication application;
3164 tet_infoline("NPatchVisual with custom shader");
3166 VisualFactory factory = VisualFactory::Get();
3167 Property::Map properties;
3168 Property::Map shader;
3169 const std::string vertexShader = "Foobar";
3170 const std::string fragmentShader = "Foobar";
3171 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3172 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3174 Property::Map transformMap;
3175 transformMap["size"] = Vector2(0.5f, 0.5f);
3176 transformMap["offset"] = Vector2(20.0f, 0.0f);
3177 transformMap["offsetPolicy"] = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3178 transformMap["anchorPoint"] = Align::CENTER;
3179 transformMap["origin"] = Align::CENTER;
3180 transformMap["extraSize"] = Vector2(0.0f, 50.0f);
3181 properties[Visual::Property::TRANSFORM] = transformMap;
3183 properties[Visual::Property::TYPE] = Visual::IMAGE;
3184 properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3185 properties[Visual::Property::SHADER] = shader;
3186 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3187 properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3189 Visual::Base visual = factory.CreateVisual(properties);
3190 TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3192 // trigger creation through setting on stage
3193 DummyControl dummy = DummyControl::New(true);
3194 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3195 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3196 dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3197 dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3198 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3199 application.GetScene().Add(dummy);
3200 application.SendNotification();
3202 Renderer renderer = dummy.GetRendererAt(0);
3203 Shader shader2 = renderer.GetShader();
3204 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3205 Property::Map* map = value.GetMap();
3206 DALI_TEST_CHECK(map);
3208 Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3209 DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3211 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3212 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3214 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3215 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3217 Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3218 DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3223 int UtcDaliGradientVisualBlendMode(void)
3225 ToolkitTestApplication application;
3226 VisualFactory factory = VisualFactory::Get();
3228 Visual::Base opaqueGradientVisual = factory.CreateVisual(
3229 Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Color::GREEN)));
3231 Visual::Base alphaGradientVisual = factory.CreateVisual(
3232 Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3234 DummyControl control = DummyControl::New(true);
3235 control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3236 application.GetScene().Add(control);
3238 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3239 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3240 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3242 application.SendNotification();
3243 application.Render();
3245 // Control should have two renderers, the first one is opaque so our blending mode should be off, the second one has some alpha so should be set to automatic
3246 DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3247 DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3248 DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3253 int UtcDaliVisualRendererRemovalAndReAddition(void)
3255 ToolkitTestApplication application;
3256 tet_infoline("UtcDaliVisualRendererRemoval");
3258 VisualFactory factory = VisualFactory::Get();
3259 Property::Map propertyMap;
3260 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3261 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3262 Visual::Base visual = factory.CreateVisual(propertyMap);
3264 visual.SetDepthIndex(1);
3266 DummyControl dummyControl = DummyControl::New(true);
3267 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3268 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3269 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3271 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3272 tet_infoline("Add control with visual to stage and check renderer count is 1");
3274 application.GetScene().Add(dummyControl);
3276 application.SendNotification();
3277 application.Render();
3279 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3281 tet_infoline("Remove control with visual from stage and check renderer count is 0");
3282 application.GetScene().Remove(dummyControl);
3283 application.SendNotification();
3284 application.Render();
3286 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3288 tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3290 application.GetScene().Add(dummyControl);
3292 application.SendNotification();
3293 application.Render();
3295 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3300 int UtcDaliVisualTextVisualRender(void)
3302 ToolkitTestApplication application;
3303 tet_infoline("UtcDaliVisualTextVisualRender");
3305 VisualFactory factory = VisualFactory::Get();
3306 Property::Map propertyMap;
3307 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3308 propertyMap.Insert("mixColor", Color::WHITE);
3309 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3310 propertyMap.Insert("enableMarkup", false);
3311 propertyMap.Insert("text", "Hello world");
3312 propertyMap.Insert("fontFamily", "TizenSans");
3314 Property::Map fontStyleMapSet;
3315 fontStyleMapSet.Insert("weight", "bold");
3316 propertyMap.Insert("fontStyle", fontStyleMapSet);
3318 propertyMap.Insert("pointSize", 12.f);
3319 propertyMap.Insert("multiLine", true);
3320 propertyMap.Insert("horizontalAlignment", "CENTER");
3321 propertyMap.Insert("verticalAlignment", "CENTER");
3322 propertyMap.Insert("textColor", Color::RED);
3323 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3324 textVisual.SetDepthIndex(1);
3326 DummyControl dummyControl = DummyControl::New(true);
3327 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3328 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3329 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3331 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3332 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3334 application.GetScene().Add(dummyControl);
3335 application.SendNotification();
3336 application.Render();
3338 // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3339 propertyMap.Clear();
3340 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3341 propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3342 propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3343 propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3345 Property::Map transformMap;
3346 transformMap.Insert("size", Vector2(0.5f, 0.5f));
3347 propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3349 textVisual = factory.CreateVisual(propertyMap);
3350 textVisual.SetDepthIndex(1);
3352 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3353 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3355 application.SendNotification(); // force process events to ensure text visual
3356 // adds renderer to the dummy control in OnRelayout
3357 application.Render();
3359 Renderer renderer = dummyControl.GetRendererAt(0u);
3360 Property::Index index = renderer.GetPropertyIndex("transformSize");
3362 tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3363 DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3368 int UtcDaliVisualTextVisualDisableEnable(void)
3370 ToolkitTestApplication application;
3371 tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3373 VisualFactory factory = VisualFactory::Get();
3374 Property::Map propertyMap;
3375 propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3376 propertyMap.Insert("mixColor", Color::WHITE);
3377 propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3378 propertyMap.Insert("enableMarkup", false);
3379 propertyMap.Insert("text", "Hello world");
3380 propertyMap.Insert("fontFamily", "TizenSans");
3382 Property::Map fontStyleMapSet;
3383 fontStyleMapSet.Insert("weight", "bold");
3384 propertyMap.Insert("fontStyle", fontStyleMapSet);
3386 propertyMap.Insert("pointSize", 12.f);
3387 propertyMap.Insert("multiLine", true);
3388 propertyMap.Insert("horizontalAlignment", "CENTER");
3389 propertyMap.Insert("verticalAlignment", "CENTER");
3390 propertyMap.Insert("textColor", Color::RED);
3391 Visual::Base textVisual = factory.CreateVisual(propertyMap);
3392 textVisual.SetDepthIndex(1);
3394 DummyControl dummyControl = DummyControl::New(true);
3395 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3396 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3397 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3399 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3400 dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3402 application.GetScene().Add(dummyControl);
3403 application.SendNotification();
3404 application.Render();
3406 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3408 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3410 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3412 dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3414 DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3419 int UtcDaliVisualPremultipliedAlpha(void)
3421 ToolkitTestApplication application;
3422 tet_infoline("UtcDaliVisualPremultipliedAlpha");
3424 VisualFactory factory = VisualFactory::Get();
3426 // image visual, test default value ( true )
3428 Visual::Base imageVisual = factory.CreateVisual(
3430 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3431 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3433 Dali::Property::Map visualMap;
3434 imageVisual.CreatePropertyMap(visualMap);
3435 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3438 DALI_TEST_CHECK(value);
3439 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3442 // image visual, override premultiplied
3444 Visual::Base imageVisual = factory.CreateVisual(
3446 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3447 .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3448 .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3450 Dali::Property::Map visualMap;
3451 imageVisual.CreatePropertyMap(visualMap);
3452 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3455 DALI_TEST_CHECK(value);
3456 DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3459 // svg visual ( premultiplied alpha by default is true )
3461 Visual::Base imageVisual = factory.CreateVisual(
3463 .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3464 .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3466 Dali::Property::Map visualMap;
3467 imageVisual.CreatePropertyMap(visualMap);
3468 Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3471 DALI_TEST_CHECK(value);
3472 DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3478 int UtcDaliRegisterVisualOrder(void)
3480 ToolkitTestApplication application;
3481 tet_infoline("Register Visual Order");
3483 DummyControl dummyControl = DummyControl::New(true);
3484 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3486 VisualFactory factory = VisualFactory::Get();
3487 Property::Map propertyMap;
3488 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3489 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3491 tet_infoline("Register visual, should have depth index of 0.0f");
3492 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3493 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3494 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3496 tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3498 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3499 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3500 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3502 Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3503 dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3504 DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3506 Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3507 dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3508 DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3510 tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3511 Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3512 labelVisual.SetDepthIndex(-2000);
3513 dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3514 DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3516 tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3517 const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3518 Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3519 DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3520 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3521 DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3523 tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3524 Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3525 anotherTestVisual2Replacement.SetDepthIndex(2000);
3526 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3527 DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3529 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3530 application.GetScene().Add(dummyControl);
3535 int UtcDaliRegisterVisualOrder02(void)
3537 ToolkitTestApplication application;
3538 tet_infoline("Register Visual Order with Background Set");
3540 DummyControl dummyControl = DummyControl::New(true);
3541 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3543 const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3545 VisualFactory factory = VisualFactory::Get();
3546 Property::Map propertyMap;
3547 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3548 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3550 tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3552 dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3554 const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3555 tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3556 Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3557 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3558 DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3560 tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3561 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3562 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3563 DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3565 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3566 application.GetScene().Add(dummyControl);
3571 int UtcDaliRegisterVisualWithDepthIndex(void)
3573 ToolkitTestApplication application;
3574 tet_infoline("Register a Visual With Depth Index");
3576 DummyControl dummyControl = DummyControl::New(true);
3577 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3579 VisualFactory factory = VisualFactory::Get();
3580 Property::Map propertyMap;
3581 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3582 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3584 tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3585 Visual::Base testVisual = factory.CreateVisual(propertyMap);
3586 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3587 DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3588 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3590 tet_infoline("Register another visual with a depth index and it disabled");
3591 Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3592 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3593 DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3594 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3596 tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3597 Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3598 DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3599 DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3600 DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3602 dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3603 application.GetScene().Add(dummyControl);
3608 int UtcDaliSvgVisualCustomShader(void)
3610 ToolkitTestApplication application;
3611 tet_infoline("SvgVisual with custom shader");
3613 VisualFactory factory = VisualFactory::Get();
3614 Property::Map properties;
3615 Property::Map shader;
3616 const std::string vertexShader = "Foobar";
3617 const std::string fragmentShader = "Foobar";
3618 shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3619 shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3621 properties[Visual::Property::TYPE] = Visual::IMAGE;
3622 properties[Visual::Property::SHADER] = shader;
3623 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3625 Visual::Base visual = factory.CreateVisual(properties);
3627 // trigger creation through setting on stage
3628 DummyControl dummy = DummyControl::New(true);
3629 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3630 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3632 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3633 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3634 application.GetScene().Add(dummy);
3636 application.SendNotification();
3637 application.Render();
3639 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3641 Renderer renderer = dummy.GetRendererAt(0);
3642 Shader shader2 = renderer.GetShader();
3643 Property::Value value = shader2.GetProperty(Shader::Property::PROGRAM);
3644 Property::Map* map = value.GetMap();
3645 DALI_TEST_CHECK(map);
3647 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3648 DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3650 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3651 DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3656 int UtcDaliVisualRoundedCorner(void)
3658 ToolkitTestApplication application;
3659 tet_infoline("UtcDaliVisualRoundedCorner");
3661 static std::vector<UniformData> customUniforms =
3663 UniformData("cornerRadius", Property::Type::VECTOR4),
3664 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3667 TestGraphicsController& graphics = application.GetGraphicsController();
3668 graphics.AddCustomUniforms(customUniforms);
3672 VisualFactory factory = VisualFactory::Get();
3673 Property::Map properties;
3674 float cornerRadius = 30.0f;
3676 properties[Visual::Property::TYPE] = Visual::IMAGE;
3677 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3678 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3680 Visual::Base visual = factory.CreateVisual(properties);
3682 // trigger creation through setting on stage
3683 DummyControl dummy = DummyControl::New(true);
3684 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3685 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3687 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3688 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3689 application.GetScene().Add(dummy);
3691 application.SendNotification();
3692 application.Render();
3694 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3696 application.SendNotification();
3697 application.Render();
3699 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3700 // Default corner radius policy is absolute.
3701 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3706 VisualFactory factory = VisualFactory::Get();
3707 Property::Map properties;
3708 float cornerRadius = 30.0f;
3710 properties[Visual::Property::TYPE] = Visual::COLOR;
3711 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3712 properties["cornerRadius"] = cornerRadius;
3713 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3715 Visual::Base visual = factory.CreateVisual(properties);
3717 // trigger creation through setting on stage
3718 DummyControl dummy = DummyControl::New(true);
3719 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3720 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3722 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3723 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3724 application.GetScene().Add(dummy);
3726 application.SendNotification();
3727 application.Render();
3729 application.SendNotification();
3730 application.Render();
3732 // Currently test with multiple program doesn't work well. will fix another day
3733 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3734 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3739 VisualFactory factory = VisualFactory::Get();
3740 Property::Map properties;
3741 Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3743 properties[Visual::Property::TYPE] = Visual::COLOR;
3744 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3745 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3746 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3748 Visual::Base visual = factory.CreateVisual(properties);
3750 // trigger creation through setting on stage
3751 DummyControl dummy = DummyControl::New(true);
3752 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3753 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3755 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3756 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3757 application.GetScene().Add(dummy);
3759 application.SendNotification();
3760 application.Render();
3762 application.SendNotification();
3763 application.Render();
3765 // Currently test with multiple program doesn't work well. will fix another day
3766 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3767 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3770 // color visual 3 - invalid value
3772 VisualFactory factory = VisualFactory::Get();
3773 Property::Map properties;
3774 Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3776 properties[Visual::Property::TYPE] = Visual::COLOR;
3777 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3778 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3779 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3781 Visual::Base visual = factory.CreateVisual(properties);
3783 // trigger creation through setting on stage
3784 DummyControl dummy = DummyControl::New(true);
3785 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3786 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3788 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3789 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3790 application.GetScene().Add(dummy);
3792 application.SendNotification();
3793 application.Render();
3795 application.SendNotification();
3796 application.Render();
3798 // Currently test with multiple program doesn't work well. will fix another day
3799 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3800 // Default corner radius policy is absolute.
3801 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3806 VisualFactory factory = VisualFactory::Get();
3807 Property::Map properties;
3808 float cornerRadius = 30.0f;
3810 properties[Visual::Property::TYPE] = Visual::GRADIENT;
3811 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3812 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3813 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3814 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
3815 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3817 Property::Array stopOffsets;
3818 stopOffsets.PushBack(0.0f);
3819 stopOffsets.PushBack(0.6f);
3820 stopOffsets.PushBack(1.0f);
3821 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3823 Property::Array stopColors;
3824 stopColors.PushBack(Color::RED);
3825 stopColors.PushBack(Color::YELLOW);
3826 stopColors.PushBack(Color::GREEN);
3827 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3829 Visual::Base visual = factory.CreateVisual(properties);
3831 // trigger creation through setting on stage
3832 DummyControl dummy = DummyControl::New(true);
3833 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3834 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3836 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3837 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3838 application.GetScene().Add(dummy);
3840 application.SendNotification();
3841 application.Render();
3843 application.SendNotification();
3844 application.Render();
3846 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3847 // Default corner radius policy is absolute.
3848 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3851 // animated image visual
3853 VisualFactory factory = VisualFactory::Get();
3854 Property::Map properties;
3855 Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3857 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3858 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3859 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
3860 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3861 properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3863 Visual::Base visual = factory.CreateVisual(properties);
3865 // trigger creation through setting on stage
3866 DummyControl dummy = DummyControl::New(true);
3867 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3868 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3870 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3871 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3872 application.GetScene().Add(dummy);
3874 application.SendNotification();
3875 application.Render();
3877 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3879 application.SendNotification();
3880 application.Render();
3882 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3883 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3886 // vector image visual
3888 VisualFactory factory = VisualFactory::Get();
3889 Property::Map properties;
3890 Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
3892 properties[Visual::Property::TYPE] = Visual::SVG;
3893 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3894 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3896 Visual::Base visual = factory.CreateVisual(properties);
3898 // trigger creation through setting on stage
3899 DummyControl dummy = DummyControl::New(true);
3900 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3901 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3903 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3904 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3905 application.GetScene().Add(dummy);
3907 application.SendNotification();
3908 application.Render();
3910 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3912 application.SendNotification();
3913 application.Render();
3915 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3916 // Default corner radius policy is absolute.
3917 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3920 // animated vector image visual
3922 VisualFactory factory = VisualFactory::Get();
3923 Property::Map properties;
3924 float cornerRadius = 1.3f;
3926 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
3927 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
3928 properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
3929 properties["cornerRadius"] = cornerRadius;
3930 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3932 Visual::Base visual = factory.CreateVisual(properties);
3934 // trigger creation through setting on stage
3935 DummyControl dummy = DummyControl::New(true);
3936 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3937 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3939 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3940 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3941 application.GetScene().Add(dummy);
3943 application.SendNotification();
3944 application.Render();
3946 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3948 application.SendNotification();
3949 application.Render();
3951 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3952 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3958 int UtcDaliVisualBorderline(void)
3960 ToolkitTestApplication application;
3961 tet_infoline("UtcDaliVisualBorderline");
3963 static std::vector<UniformData> customUniforms =
3965 UniformData("cornerRadius", Property::Type::VECTOR4),
3966 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3967 UniformData("borderlineWidth", Property::Type::FLOAT),
3968 UniformData("borderlineColor", Property::Type::VECTOR4),
3969 UniformData("borderlineOffset", Property::Type::FLOAT),
3972 TestGraphicsController& graphics = application.GetGraphicsController();
3973 graphics.AddCustomUniforms(customUniforms);
3977 VisualFactory factory = VisualFactory::Get();
3978 Property::Map properties;
3979 float cornerRadius = 5.0f;
3980 float borderlineWidth = 30.0f;
3981 Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
3982 float borderlineOffset = 1.0f;
3984 properties[Visual::Property::TYPE] = Visual::IMAGE;
3985 properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3986 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3987 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
3988 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
3989 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
3991 Visual::Base visual = factory.CreateVisual(properties);
3993 // trigger creation through setting on stage
3994 DummyControl dummy = DummyControl::New(true);
3995 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3996 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3998 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3999 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4000 application.GetScene().Add(dummy);
4002 application.SendNotification();
4003 application.Render();
4005 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4007 application.SendNotification();
4008 application.Render();
4010 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4011 // Default corner radius policy is absolute.
4012 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4013 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4014 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4015 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4020 VisualFactory factory = VisualFactory::Get();
4021 Property::Map properties;
4022 Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4023 float borderlineWidth = 30.0f;
4024 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4025 float borderlineOffset = -0.4f;
4027 properties[Visual::Property::TYPE] = Visual::COLOR;
4028 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4029 properties["cornerRadius"] = cornerRadius;
4030 properties["borderlineWidth"] = borderlineWidth;
4031 properties["borderlineColor"] = borderlineColor;
4032 properties["borderlineOffset"] = borderlineOffset;
4034 Visual::Base visual = factory.CreateVisual(properties);
4036 // trigger creation through setting on stage
4037 DummyControl dummy = DummyControl::New(true);
4038 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4039 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4041 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4042 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4043 application.GetScene().Add(dummy);
4045 application.SendNotification();
4046 application.Render();
4048 application.SendNotification();
4049 application.Render();
4051 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4052 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4053 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4054 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4057 // color visual 2, default color, default offset
4059 VisualFactory factory = VisualFactory::Get();
4060 Property::Map properties;
4061 float borderlineWidth = 30.0f;
4063 properties[Visual::Property::TYPE] = Visual::COLOR;
4064 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4065 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4067 Visual::Base visual = factory.CreateVisual(properties);
4069 // trigger creation through setting on stage
4070 DummyControl dummy = DummyControl::New(true);
4071 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4072 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4074 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4075 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4076 application.GetScene().Add(dummy);
4078 application.SendNotification();
4079 application.Render();
4081 application.SendNotification();
4082 application.Render();
4084 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4085 // Default borderline color is BLACK.
4086 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4087 // Default borderline offset is 0.0f.
4088 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4091 // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4093 VisualFactory factory = VisualFactory::Get();
4094 Property::Map properties;
4095 float borderlineWidth = 30.0f;
4096 Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4097 float borderlineOffset = 37.4f;
4099 properties[Visual::Property::TYPE] = Visual::COLOR;
4100 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4101 properties["borderlineWidth"] = borderlineWidth;
4102 properties["borderlineColor"] = borderlineColor;
4103 properties["borderlineOffset"] = borderlineOffset;
4105 Visual::Base visual = factory.CreateVisual(properties);
4107 // trigger creation through setting on stage
4108 DummyControl dummy = DummyControl::New(true);
4109 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4110 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4112 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4113 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4114 application.GetScene().Add(dummy);
4116 application.SendNotification();
4117 application.Render();
4119 application.SendNotification();
4120 application.Render();
4122 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4123 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4124 // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4125 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4130 VisualFactory factory = VisualFactory::Get();
4131 Property::Map properties;
4132 float borderlineWidth = 30.0f;
4133 float cornerRadius = 70.0f;
4135 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4136 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4137 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4138 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4139 properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4140 properties[GradientVisual::Property::END_POSITION] = Vector2(-0.5f, -0.5f);
4141 properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4143 Property::Array stopOffsets;
4144 stopOffsets.PushBack(0.0f);
4145 stopOffsets.PushBack(0.6f);
4146 stopOffsets.PushBack(1.0f);
4147 properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4149 Property::Array stopColors;
4150 stopColors.PushBack(Color::RED);
4151 stopColors.PushBack(Color::YELLOW);
4152 stopColors.PushBack(Color::GREEN);
4153 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4155 Visual::Base visual = factory.CreateVisual(properties);
4157 // trigger creation through setting on stage
4158 DummyControl dummy = DummyControl::New(true);
4159 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4160 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4162 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4163 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4164 application.GetScene().Add(dummy);
4166 application.SendNotification();
4167 application.Render();
4169 application.SendNotification();
4170 application.Render();
4172 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4173 // Default corner radius policy is absolute.
4174 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4175 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4176 // Default borderline color is BLACK.
4177 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4178 // Default borderline offset is 0.0f.
4179 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4182 // animated image visual
4184 VisualFactory factory = VisualFactory::Get();
4185 Property::Map properties;
4186 float borderlineWidth = 24.0f;
4187 float borderlineOffset = -1.0f;
4189 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4190 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4191 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4192 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4193 properties["borderlineOffset"] = borderlineOffset;
4195 Visual::Base visual = factory.CreateVisual(properties);
4197 // trigger creation through setting on stage
4198 DummyControl dummy = DummyControl::New(true);
4199 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4200 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4202 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4203 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4204 application.GetScene().Add(dummy);
4206 application.SendNotification();
4207 application.Render();
4209 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4211 application.SendNotification();
4212 application.Render();
4214 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4215 // Default borderline color is BLACK.
4216 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4217 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4220 // vector image visual
4222 VisualFactory factory = VisualFactory::Get();
4223 Property::Map properties;
4224 Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4225 float borderlineWidth = 27.0f;
4226 Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4228 properties[Visual::Property::TYPE] = Visual::SVG;
4229 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4230 properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4231 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4232 properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4234 Visual::Base visual = factory.CreateVisual(properties);
4236 // trigger creation through setting on stage
4237 DummyControl dummy = DummyControl::New(true);
4238 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4239 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4241 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4242 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4243 application.GetScene().Add(dummy);
4245 application.SendNotification();
4246 application.Render();
4248 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4250 application.SendNotification();
4251 application.Render();
4253 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4254 // Default corner radius policy is absolute.
4255 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4256 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4257 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4258 // Default borderline offset is 0.0.
4259 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4262 // animated vector image visual
4264 VisualFactory factory = VisualFactory::Get();
4265 Property::Map properties;
4266 Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4267 float borderlineWidth = 13.0f;
4268 Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4269 float borderlineOffset = 13.0f;
4271 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4272 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4273 properties["cornerRadius"] = cornerRadius;
4274 properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4275 properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4276 properties["borderlineColor"] = borderlineColor;
4277 properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4279 Visual::Base visual = factory.CreateVisual(properties);
4281 // trigger creation through setting on stage
4282 DummyControl dummy = DummyControl::New(true);
4283 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4284 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4286 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4287 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4288 application.GetScene().Add(dummy);
4290 application.SendNotification();
4291 application.Render();
4293 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4295 application.SendNotification();
4296 application.Render();
4298 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4299 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4300 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4301 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4302 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4308 int UtcDaliVisualBorderlineBlendModeTest(void)
4310 ToolkitTestApplication application;
4311 tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4312 VisualFactory factory = VisualFactory::Get();
4314 // Case 1 : Test which doesn't support borderline feature.
4316 tet_printf("Test Unsupported visual type\n");
4317 Property::Map propertyMap;
4318 propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4319 propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4320 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4321 Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4323 DummyControl actor = DummyControl::New(true);
4324 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4325 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4326 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4327 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4328 application.GetScene().Add(actor);
4330 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4332 Renderer renderer = actor.GetRendererAt(0);
4334 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4335 // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4336 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4338 application.GetScene().Remove(actor);
4341 // Case 2 : Test which support borderline feature.
4343 tet_printf("Test normal case\n");
4344 Property::Map propertyMap;
4345 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4346 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4347 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4348 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4350 DummyControl actor = DummyControl::New(true);
4351 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4352 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4353 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4354 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4355 application.GetScene().Add(actor);
4357 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4359 Renderer renderer = actor.GetRendererAt(0);
4361 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4362 // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4363 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4365 application.GetScene().Remove(actor);
4368 // Case 3 : Test which animated borderline.
4370 tet_printf("Test borderline animate case\n");
4371 Property::Map propertyMap;
4372 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4373 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4374 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4376 DummyControl actor = DummyControl::New(true);
4377 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4378 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4379 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4380 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4381 application.GetScene().Add(actor);
4383 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4385 Renderer renderer = actor.GetRendererAt(0);
4387 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4388 // BlendMode is AUTO.
4389 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4391 Animation animation = Animation::New(0.1f);
4392 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4395 application.SendNotification();
4396 application.Render();
4397 application.Render(101u); // End of animation
4399 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4400 // BlendMode is ON_WITHOUT_CULL.
4401 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4403 Animation revanimation = Animation::New(0.1f);
4404 revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4405 revanimation.Play();
4407 application.SendNotification();
4408 application.Render();
4409 application.Render(101u); // End of animation
4411 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4412 // BlendMode is still ON_WITHOUT_CULL.
4413 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4415 application.GetScene().Remove(actor);
4418 // Case 4 : Test which animated corner radius occur.
4420 tet_printf("Test borderline animate case\n");
4421 Property::Map propertyMap;
4422 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4423 propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4424 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4425 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4427 DummyControl actor = DummyControl::New(true);
4428 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4429 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4430 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4431 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4432 application.GetScene().Add(actor);
4434 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4436 Renderer renderer = actor.GetRendererAt(0);
4438 Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4439 // BlendMode is ON_WITHOUT_CULL.
4440 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4442 Animation animation = Animation::New(0.1f);
4443 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4446 application.SendNotification();
4447 application.Render();
4448 application.Render(101u); // End of animation
4450 blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4451 // BlendMode is ON_WITHOUT_CULL.
4452 DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4454 application.GetScene().Remove(actor);
4460 int UtcDaliVisualBorderlineColorAnimateTest(void)
4462 ToolkitTestApplication application;
4463 tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4465 TestGraphicsController& graphics = application.GetGraphicsController();
4466 static std::vector<UniformData> customUniforms =
4468 UniformData("mixColor", Property::Type::VECTOR3),
4469 UniformData("cornerRadius", Property::Type::VECTOR4),
4470 UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4471 UniformData("borderlineWidth", Property::Type::FLOAT),
4472 UniformData("borderlineColor", Property::Type::VECTOR4),
4473 UniformData("borderlineOffset", Property::Type::FLOAT),
4475 graphics.AddCustomUniforms(customUniforms);
4478 const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4479 const float INITIAL_MIX_OPACITY(0.5f);
4480 const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4481 const float INITIAL_ACTOR_OPACITY(1.0f);
4482 const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4483 const float TARGET_MIX_OPACITY(0.8f);
4484 const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4485 const float TARGET_ACTOR_OPACITY(0.5f);
4487 VisualFactory factory = VisualFactory::Get();
4488 Property::Map propertyMap;
4489 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4490 propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4491 propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4492 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4493 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4494 Visual::Base visual = factory.CreateVisual(propertyMap);
4496 DummyControl actor = DummyControl::New(true);
4497 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4498 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4499 actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4500 actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4501 actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4502 application.GetScene().Add(actor);
4504 DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4506 Animation animation = Animation::New(4.0f);
4507 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4508 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4509 animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4510 animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4513 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4515 application.SendNotification();
4516 application.Render(0);
4517 application.Render(2000u); // halfway point
4518 application.SendNotification();
4520 Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4521 float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4522 Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4523 float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4524 halfwayMixOpacity *= halfwayActorOpacity;
4525 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4526 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4527 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4528 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4530 application.Render(2001u); // go past end
4531 application.SendNotification(); // Trigger signals
4533 DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4534 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4535 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4536 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4537 DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4545 int UtcDaliColorVisualBlurRadius(void)
4547 ToolkitTestApplication application;
4548 tet_infoline("UtcDaliColorVisualBlurRadius");
4550 static std::vector<UniformData> customUniforms =
4552 UniformData("blurRadius", Property::Type::FLOAT),
4555 TestGraphicsController& graphics = application.GetGraphicsController();
4556 graphics.AddCustomUniforms(customUniforms);
4558 VisualFactory factory = VisualFactory::Get();
4559 Property::Map properties;
4560 float blurRadius = 20.0f;
4562 properties[Visual::Property::TYPE] = Visual::COLOR;
4563 properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4564 properties["blurRadius"] = blurRadius;
4566 Visual::Base visual = factory.CreateVisual(properties);
4568 // trigger creation through setting on stage
4569 DummyControl dummy = DummyControl::New(true);
4570 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4571 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4573 dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4574 dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4575 application.GetScene().Add(dummy);
4577 application.SendNotification();
4578 application.Render();
4580 application.SendNotification();
4581 application.Render();
4583 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4588 int UtcDaliVisualGetType(void)
4590 ToolkitTestApplication application;
4591 tet_infoline("UtcDaliVisualGetType");
4593 VisualFactory factory = VisualFactory::Get();
4596 Property::Map properties;
4597 properties[Visual::Property::TYPE] = Visual::BORDER;
4598 Visual::Base visual = factory.CreateVisual(properties);
4600 DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4604 Property::Map properties;
4605 properties[Visual::Property::TYPE] = Visual::COLOR;
4606 Visual::Base visual = factory.CreateVisual(properties);
4608 DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4612 Property::Map properties;
4613 properties[Visual::Property::TYPE] = Visual::GRADIENT;
4614 properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4615 properties[GradientVisual::Property::END_POSITION] = Vector2(1.f, 1.f);
4616 properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4617 // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4618 Property::Array stopColors;
4619 stopColors.PushBack(Color::RED);
4620 stopColors.PushBack(Color::GREEN);
4621 properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4622 Visual::Base visual = factory.CreateVisual(properties);
4624 DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4628 Property::Map properties;
4629 properties[Visual::Property::TYPE] = Visual::IMAGE;
4630 properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4631 Visual::Base visual = factory.CreateVisual(properties);
4633 DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4637 Property::Map properties;
4638 properties[Visual::Property::TYPE] = Visual::MESH;
4639 Visual::Base visual = factory.CreateVisual(properties);
4641 DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4645 Property::Map properties;
4646 properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4647 properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4648 Visual::Base visual = factory.CreateVisual(properties);
4650 DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4654 Property::Map properties;
4655 properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4656 Visual::Base visual = factory.CreateVisual(properties);
4658 DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4662 Property::Map properties;
4663 properties[Visual::Property::TYPE] = Visual::TEXT;
4664 Visual::Base visual = factory.CreateVisual(properties);
4666 DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4670 Property::Map properties;
4671 properties[Visual::Property::TYPE] = Visual::N_PATCH;
4672 properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4673 Visual::Base visual = factory.CreateVisual(properties);
4675 DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4679 Property::Map properties;
4680 properties[Visual::Property::TYPE] = Visual::SVG;
4681 properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4682 Visual::Base visual = factory.CreateVisual(properties);
4684 DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4688 Property::Map properties;
4689 properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4690 properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4691 Visual::Base visual = factory.CreateVisual(properties);
4693 DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4697 Property::Map properties;
4698 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4699 Visual::Base visual = factory.CreateVisual(properties);
4701 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4705 Property::Map properties;
4706 properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4707 properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4708 Visual::Base visual = factory.CreateVisual(properties);
4710 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4714 Property::Map properties;
4715 properties[Visual::Property::TYPE] = DevelVisual::ARC;
4716 Visual::Base visual = factory.CreateVisual(properties);
4718 DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4724 int UtcDaliVisualGetVisualProperty01(void)
4726 ToolkitTestApplication application;
4727 tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4729 static std::vector<UniformData> customUniforms =
4731 UniformData("mixColor", Property::Type::VECTOR3),
4732 UniformData("offset", Property::Type::VECTOR2),
4733 UniformData("size", Property::Type::VECTOR2),
4734 UniformData("cornerRadius", Property::Type::VECTOR4),
4735 UniformData("blurRadius", Property::Type::FLOAT),
4736 UniformData("borderlineWidth", Property::Type::FLOAT),
4737 UniformData("borderlineColor", Property::Type::VECTOR4),
4738 UniformData("borderlineOffset", Property::Type::FLOAT),
4739 UniformData("preMultipliedAlpha", Property::Type::FLOAT)};
4741 TestGraphicsController& graphics = application.GetGraphicsController();
4742 graphics.AddCustomUniforms(customUniforms);
4744 VisualFactory factory = VisualFactory::Get();
4745 Property::Map propertyMap;
4746 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4747 propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4748 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4749 propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4750 propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4751 propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4752 propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4753 propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4754 propertyMap.Insert(Visual::Property::PREMULTIPLIED_ALPHA, true);
4755 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4757 DummyControl dummyControl = DummyControl::New(true);
4758 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4759 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4760 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4761 application.GetScene().Add(dummyControl);
4763 application.SendNotification();
4764 application.Render();
4766 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4767 Vector2 targetOffset(0.05f, 0.05f);
4768 Vector2 targetSize(1.1f, 1.1f);
4769 float targetOpacity = 0.5f;
4770 Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4771 float targetBlurRadius = 10.0f;
4772 float targetBorderlineWidth = 25.0f;
4773 Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4774 float targetBorderlineOffset = -1.0f;
4775 float targetPreMultipliedAlpha = 1.0f;
4777 Animation animation = Animation::New(1.0f);
4778 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4779 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4780 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4781 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4782 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4783 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4784 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4785 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4786 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4789 application.SendNotification();
4790 application.Render();
4791 application.Render(1001u); // End of animation
4793 Property::Map resultMap;
4794 colorVisual.CreatePropertyMap(resultMap);
4796 // Test property values: they should be updated
4797 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4798 DALI_TEST_CHECK(colorValue);
4799 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4801 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4802 Dali::Property::Map* transformMap = transformValue->GetMap();
4803 DALI_TEST_CHECK(transformMap);
4805 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4806 DALI_TEST_CHECK(offsetValue);
4807 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4809 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4810 DALI_TEST_CHECK(sizeValue);
4811 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4813 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4814 DALI_TEST_CHECK(cornerRadiusValue);
4815 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4817 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4818 DALI_TEST_CHECK(blurRadiusValue);
4819 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4821 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4822 DALI_TEST_CHECK(borderlineWidthValue);
4823 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4825 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4826 DALI_TEST_CHECK(borderlineColorValue);
4827 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4829 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4830 DALI_TEST_CHECK(borderlineOffsetValue);
4831 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4833 Property::Value* preMultAlphaValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
4834 DALI_TEST_CHECK(preMultAlphaValue);
4835 DALI_TEST_EQUALS(preMultAlphaValue->Get<bool>(), bool(targetPreMultipliedAlpha), TEST_LOCATION);
4837 // Test uniform values
4838 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4839 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4840 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4841 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4842 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4843 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4844 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4845 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4846 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("preMultipliedAlpha", targetPreMultipliedAlpha), true, TEST_LOCATION);
4848 // Test unregistered visual
4849 Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4850 DALI_TEST_CHECK(!property3.object);
4851 DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4856 int UtcDaliVisualGetVisualProperty02(void)
4858 ToolkitTestApplication application;
4859 tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
4861 static std::vector<UniformData> customUniforms =
4863 UniformData("mixColor", Property::Type::VECTOR3),
4864 UniformData("offset", Property::Type::VECTOR2),
4865 UniformData("size", Property::Type::VECTOR2),
4866 UniformData("cornerRadius", Property::Type::VECTOR4),
4867 UniformData("borderlineWidth", Property::Type::FLOAT),
4868 UniformData("borderlineCOlor", Property::Type::VECTOR4),
4869 UniformData("borderlineOffset", Property::Type::FLOAT),
4870 UniformData("blurRadius", Property::Type::FLOAT),
4873 TestGraphicsController& graphics = application.GetGraphicsController();
4874 graphics.AddCustomUniforms(customUniforms);
4876 VisualFactory factory = VisualFactory::Get();
4877 Property::Map propertyMap;
4878 propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4879 Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4881 DummyControl dummyControl = DummyControl::New(true);
4882 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4883 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4884 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4885 application.GetScene().Add(dummyControl);
4887 application.SendNotification();
4888 application.Render();
4890 Vector3 targetColor(1.0f, 1.0f, 1.0f);
4891 Vector2 targetOffset(0.05f, 0.05f);
4892 Vector2 targetSize(1.1f, 1.1f);
4893 float targetOpacity = 0.5f;
4894 Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
4895 float targetBorderlineWidth = 77.7f;
4896 Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
4897 float targetBorderlineOffset = 1.0f;
4898 float targetBlurRadius = 10.0f;
4900 // Should work when the properties are not set before
4901 Animation animation = Animation::New(1.0f);
4902 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
4903 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
4904 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
4905 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
4906 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
4907 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
4908 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
4909 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
4910 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
4913 application.SendNotification();
4914 application.Render();
4915 application.Render(1001u); // End of animation
4917 Property::Map resultMap;
4918 colorVisual.CreatePropertyMap(resultMap);
4920 // Test property values: they should be updated
4921 Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4922 DALI_TEST_CHECK(colorValue);
4923 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4925 Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4926 Dali::Property::Map* transformMap = transformValue->GetMap();
4927 DALI_TEST_CHECK(transformMap);
4929 Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4930 DALI_TEST_CHECK(offsetValue);
4931 DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4933 Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4934 DALI_TEST_CHECK(sizeValue);
4935 DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4937 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4938 DALI_TEST_CHECK(cornerRadiusValue);
4939 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4941 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4942 DALI_TEST_CHECK(borderlineWidthValue);
4943 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4945 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4946 DALI_TEST_CHECK(borderlineColorValue);
4947 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4949 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4950 DALI_TEST_CHECK(borderlineOffsetValue);
4951 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4953 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4954 DALI_TEST_CHECK(blurRadiusValue);
4955 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4957 // Test uniform values
4958 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4959 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4960 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4961 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4962 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4967 int UtcDaliVisualGetVisualProperty03(void)
4969 ToolkitTestApplication application;
4970 tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
4972 static std::vector<UniformData> customUniforms =
4974 UniformData("cornerRadius", Property::Type::VECTOR4),
4975 UniformData("borderlineWidth", Property::Type::FLOAT),
4976 UniformData("borderlineColor", Property::Type::VECTOR4),
4977 UniformData("borderlineOffset", Property::Type::FLOAT),
4980 TestGraphicsController& graphics = application.GetGraphicsController();
4981 graphics.AddCustomUniforms(customUniforms);
4983 VisualFactory factory = VisualFactory::Get();
4984 Property::Map propertyMap;
4985 propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
4986 propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4988 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
4990 DummyControl dummyControl = DummyControl::New(true);
4991 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4992 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
4993 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4994 application.GetScene().Add(dummyControl);
4996 // Wait for image loading
4997 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4999 application.SendNotification();
5000 application.Render();
5002 float targetOpacity = 0.5f;
5003 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5004 float targetBorderlineWidth = 10.0f;
5005 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5006 float targetBorderlineOffset = -1.5f;
5008 Animation animation = Animation::New(1.0f);
5009 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5010 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5011 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5012 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5013 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5016 application.SendNotification();
5017 application.Render();
5018 application.Render(1001u); // End of animation
5020 Property::Map resultMap;
5021 imageVisual.CreatePropertyMap(resultMap);
5023 // Test property values: they should be updated
5024 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5025 DALI_TEST_CHECK(colorValue);
5026 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5028 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5029 DALI_TEST_CHECK(cornerRadiusValue);
5030 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5032 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5033 DALI_TEST_CHECK(borderlineWidthValue);
5034 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5036 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5037 DALI_TEST_CHECK(borderlineColorValue);
5038 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5040 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5041 DALI_TEST_CHECK(borderlineOffsetValue);
5042 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5044 // Test uniform value
5045 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5046 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5047 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5048 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5053 int UtcDaliVisualGetVisualProperty04(void)
5055 ToolkitTestApplication application;
5056 tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5058 static std::vector<UniformData> customUniforms =
5060 UniformData("cornerRadius", Property::Type::VECTOR4),
5063 TestGraphicsController& graphics = application.GetGraphicsController();
5064 graphics.AddCustomUniforms(customUniforms);
5066 Vector2 start(-1.f, -1.f);
5067 Vector2 end(1.f, 1.f);
5068 Property::Array stopColors;
5069 stopColors.PushBack(Color::RED);
5070 stopColors.PushBack(Color::GREEN);
5072 VisualFactory factory = VisualFactory::Get();
5073 Property::Map propertyMap;
5074 propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5075 propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5076 propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5077 propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5078 propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5079 propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5080 Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5082 DummyControl dummyControl = DummyControl::New(true);
5083 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5084 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5085 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5086 application.GetScene().Add(dummyControl);
5088 application.SendNotification();
5089 application.Render();
5091 float targetOpacity = 0.5f;
5092 Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5094 Animation animation = Animation::New(1.0f);
5095 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5096 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5099 application.SendNotification();
5100 application.Render();
5101 application.Render(1001u); // End of animation
5103 Property::Map resultMap;
5104 gradientVisual.CreatePropertyMap(resultMap);
5106 // Test property values: they should be updated
5107 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5108 DALI_TEST_CHECK(colorValue);
5109 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5111 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5112 DALI_TEST_CHECK(cornerRadiusValue);
5113 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5115 // Test uniform value
5116 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5121 int UtcDaliVisualGetVisualProperty05(void)
5123 ToolkitTestApplication application;
5124 tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5126 static std::vector<UniformData> customUniforms =
5128 UniformData("cornerRadius", Property::Type::VECTOR4),
5129 UniformData("borderlineWidth", Property::Type::FLOAT),
5130 UniformData("borderlineColor", Property::Type::VECTOR4),
5131 UniformData("borderlineOffset", Property::Type::FLOAT),
5134 TestGraphicsController& graphics = application.GetGraphicsController();
5135 graphics.AddCustomUniforms(customUniforms);
5137 VisualFactory factory = VisualFactory::Get();
5138 Property::Map propertyMap;
5139 propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5140 propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5142 Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5144 DummyControl dummyControl = DummyControl::New(true);
5145 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5146 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5147 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5148 application.GetScene().Add(dummyControl);
5150 application.SendNotification();
5151 application.Render();
5153 // Wait for image loading
5154 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5156 application.SendNotification();
5157 application.Render();
5159 float targetOpacity = 0.5f;
5160 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5161 float targetBorderlineWidth = 10.0f;
5162 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5163 float targetBorderlineOffset = -1.5f;
5165 Animation animation = Animation::New(1.0f);
5166 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5167 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5168 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5169 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5170 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5173 application.SendNotification();
5174 application.Render();
5175 application.Render(1001u); // End of animation
5177 Property::Map resultMap;
5178 svgVisual.CreatePropertyMap(resultMap);
5180 // Test property values: they should be updated
5181 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5182 DALI_TEST_CHECK(colorValue);
5183 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5185 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5186 DALI_TEST_CHECK(cornerRadiusValue);
5187 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5189 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5190 DALI_TEST_CHECK(borderlineWidthValue);
5191 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5193 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5194 DALI_TEST_CHECK(borderlineColorValue);
5195 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5197 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5198 DALI_TEST_CHECK(borderlineOffsetValue);
5199 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5201 // Currently test with multiple program doesn't work well. will fix another day
5202 // Test uniform value
5203 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5204 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5205 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5206 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5211 int UtcDaliVisualGetVisualProperty06(void)
5213 ToolkitTestApplication application;
5214 tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5216 static std::vector<UniformData> customUniforms =
5218 UniformData("cornerRadius", Property::Type::VECTOR4),
5219 UniformData("borderlineWidth", Property::Type::FLOAT),
5220 UniformData("borderlineColor", Property::Type::VECTOR4),
5221 UniformData("borderlineOffset", Property::Type::FLOAT),
5224 TestGraphicsController& graphics = application.GetGraphicsController();
5225 graphics.AddCustomUniforms(customUniforms);
5227 VisualFactory factory = VisualFactory::Get();
5228 Property::Map propertyMap;
5229 propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5230 propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5232 Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5234 DummyControl dummyControl = DummyControl::New(true);
5235 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5236 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5237 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5238 application.GetScene().Add(dummyControl);
5240 application.SendNotification();
5241 application.Render();
5243 // Wait for image loading
5244 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5246 application.SendNotification();
5247 application.Render();
5249 float targetOpacity = 0.5f;
5250 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5251 float targetBorderlineWidth = 10.0f;
5252 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5253 float targetBorderlineOffset = -1.5f;
5255 Animation animation = Animation::New(1.0f);
5256 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5257 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5258 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5259 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5260 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5263 application.SendNotification();
5264 application.Render();
5265 application.Render(1001u); // End of animation
5267 Property::Map resultMap;
5268 animatedImageVisual.CreatePropertyMap(resultMap);
5270 // Test property values: they should be updated
5271 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5272 DALI_TEST_CHECK(colorValue);
5273 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5275 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5276 DALI_TEST_CHECK(cornerRadiusValue);
5277 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5279 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5280 DALI_TEST_CHECK(borderlineWidthValue);
5281 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5283 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5284 DALI_TEST_CHECK(borderlineColorValue);
5285 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5287 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5288 DALI_TEST_CHECK(borderlineOffsetValue);
5289 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5291 // Currently test with multiple program doesn't work well. will fix another day
5292 // Test uniform value
5293 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5294 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5295 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5296 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5301 int UtcDaliVisualGetVisualProperty07(void)
5303 ToolkitTestApplication application;
5304 tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5306 static std::vector<UniformData> customUniforms =
5308 UniformData("cornerRadius", Property::Type::VECTOR4),
5309 UniformData("borderlineWidth", Property::Type::FLOAT),
5310 UniformData("borderlineColor", Property::Type::VECTOR4),
5311 UniformData("borderlineOffset", Property::Type::FLOAT),
5314 TestGraphicsController& graphics = application.GetGraphicsController();
5315 graphics.AddCustomUniforms(customUniforms);
5317 VisualFactory factory = VisualFactory::Get();
5318 Property::Map propertyMap;
5319 propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5320 propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5322 Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5324 DummyControl dummyControl = DummyControl::New(true);
5325 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5326 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5327 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5328 application.GetScene().Add(dummyControl);
5330 application.SendNotification();
5331 application.Render();
5333 // Wait for image loading
5334 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5336 application.SendNotification();
5337 application.Render();
5339 float targetOpacity = 0.5f;
5340 Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5341 float targetBorderlineWidth = 10.0f;
5342 Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5343 float targetBorderlineOffset = -1.5f;
5345 Animation animation = Animation::New(1.0f);
5346 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5347 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5348 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5349 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5350 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5353 application.SendNotification();
5354 application.Render();
5355 application.Render(1001u); // End of animation
5357 Property::Map resultMap;
5358 animatedVectorVisual.CreatePropertyMap(resultMap);
5360 // Test property values: they should be updated
5361 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5362 DALI_TEST_CHECK(colorValue);
5363 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5365 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5366 DALI_TEST_CHECK(cornerRadiusValue);
5367 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5369 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5370 DALI_TEST_CHECK(borderlineWidthValue);
5371 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5373 Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5374 DALI_TEST_CHECK(borderlineColorValue);
5375 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5377 Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5378 DALI_TEST_CHECK(borderlineOffsetValue);
5379 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5381 // Currently test with multiple program doesn't work well. will fix another day
5382 // Test uniform value
5383 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5384 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5385 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5386 DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5391 int UtcDaliVisualUpdateProperty(void)
5393 ToolkitTestApplication application;
5394 tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5396 VisualFactory factory = VisualFactory::Get();
5397 Property::Map propertyMap;
5398 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5399 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5400 propertyMap[Visual::Property::MIX_COLOR] = Color::BLUE;
5401 propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5403 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5405 DummyControl dummyControl = DummyControl::New(true);
5406 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5407 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5408 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5409 application.GetScene().Add(dummyControl);
5411 application.SendNotification();
5412 application.Render();
5414 // Wait for image loading
5415 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5417 application.SendNotification();
5418 application.Render();
5420 Property::Map originalMap;
5421 imageVisual.CreatePropertyMap(originalMap);
5423 float targetOpacity = 0.5f;
5424 Vector3 targetMixColor = Vector3(1.0f, 0.4f, 0.2f);
5425 bool targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5426 DevelVisual::FittingMode targetVisualFittingMode = DevelVisual::CENTER;
5428 Property::Map targetPropertyMap;
5429 targetPropertyMap[Visual::Property::OPACITY] = targetOpacity;
5430 targetPropertyMap[ImageVisual::Property::URL] = "foobar";
5431 targetPropertyMap[Visual::Property::MIX_COLOR] = targetMixColor;
5432 targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA] = targetPreMultipliedAlpha;
5433 targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5435 // Update Properties
5436 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5438 Property::Map resultMap;
5439 imageVisual.CreatePropertyMap(resultMap);
5441 // Test property values: they should be updated
5442 Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5443 DALI_TEST_CHECK(colorValue);
5444 DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5446 Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5447 DALI_TEST_CHECK(urlValue);
5448 // NOTE : ImageVisual URL must NOT changed.
5449 DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5451 Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5452 DALI_TEST_CHECK(preMultipliedValue);
5453 DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5455 Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5456 DALI_TEST_CHECK(visualFittingModeValue);
5457 DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5462 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5464 ToolkitTestApplication application;
5465 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5467 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5469 VisualFactory factory = VisualFactory::Get();
5470 Property::Map propertyMap;
5472 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5473 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5475 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5477 DummyControl dummyControl = DummyControl::New(true);
5478 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5479 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5480 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5481 application.GetScene().Add(dummyControl);
5483 application.SendNotification();
5484 application.Render();
5486 // Wait for image loading
5487 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5489 application.SendNotification();
5490 application.Render();
5494 Renderer renderer = dummyControl.GetRendererAt(0);
5495 Shader shader = renderer.GetShader();
5496 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5497 Property::Map* map = value.GetMap();
5498 DALI_TEST_CHECK(map);
5500 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5501 DALI_TEST_CHECK(fragment);
5502 std::string fragmentShader;
5503 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5504 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5505 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5507 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5508 std::string vertexShader;
5509 DALI_TEST_CHECK(vertex->Get(vertexShader));
5510 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5511 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5514 callStack.Enable(true);
5516 Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5518 Property::Map targetPropertyMap;
5519 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5520 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5522 // Update Properties with CornerRadius
5523 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5525 Property::Map resultMap;
5526 imageVisual.CreatePropertyMap(resultMap);
5528 // Test property values: they should be updated
5529 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5530 DALI_TEST_CHECK(cornerRadiusValue);
5531 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5533 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5534 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5535 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5539 Renderer renderer = dummyControl.GetRendererAt(0);
5540 Shader shader = renderer.GetShader();
5541 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5542 Property::Map* map = value.GetMap();
5543 DALI_TEST_CHECK(map);
5545 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5546 DALI_TEST_CHECK(fragment);
5547 std::string fragmentShader;
5548 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5549 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5550 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5552 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5553 std::string vertexShader;
5554 DALI_TEST_CHECK(vertex->Get(vertexShader));
5555 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5556 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5559 // Send shader compile signal
5560 application.SendNotification();
5561 application.Render();
5563 callStack.Enable(false);
5565 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5567 callStack.Enable(true);
5569 float targetBorderlineWidth = 10.0f;
5570 Vector4 targetBorderlineColor = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5571 float targetBorderlineOffset = -0.3f;
5573 Property::Map targetPropertyMap2;
5574 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5575 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5576 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5577 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5578 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5580 // Update Properties with Borderline
5581 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5583 Property::Map resultMap2;
5584 imageVisual.CreatePropertyMap(resultMap2);
5586 // Test property values: they should be updated
5587 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5588 DALI_TEST_CHECK(cornerRadiusValue);
5589 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5591 cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5592 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5593 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5595 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5596 DALI_TEST_CHECK(borderlineWidthValue);
5597 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5599 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5600 DALI_TEST_CHECK(borderlineColorValue);
5601 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5603 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5604 DALI_TEST_CHECK(borderlineOffsetValue);
5605 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5609 Renderer renderer = dummyControl.GetRendererAt(0);
5610 Shader shader = renderer.GetShader();
5611 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5612 Property::Map* map = value.GetMap();
5613 DALI_TEST_CHECK(map);
5615 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5616 DALI_TEST_CHECK(fragment);
5617 std::string fragmentShader;
5618 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5619 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5620 // Note : mAlwaysUsingCornerRadius is true.
5621 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5623 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5624 std::string vertexShader;
5625 DALI_TEST_CHECK(vertex->Get(vertexShader));
5626 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5627 // Note : mAlwaysUsingCornerRadius is true.
5628 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5631 // Send shader compile signal
5632 application.SendNotification();
5633 application.Render();
5635 callStack.Enable(false);
5637 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5639 callStack.Enable(true);
5641 Property::Map targetPropertyMap3;
5642 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5643 targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5644 targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH] = 0.0f;
5645 targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR] = Vector4::ZERO;
5646 targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET] = 0.0f;
5648 // Update Properties into zero
5649 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5651 Property::Map resultMap3;
5652 imageVisual.CreatePropertyMap(resultMap3);
5654 // Test property values: they should be updated
5655 cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5656 DALI_TEST_CHECK(cornerRadiusValue);
5657 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5659 cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5660 DALI_TEST_CHECK(cornerRadiusPolicyValue);
5661 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5663 borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5664 DALI_TEST_CHECK(borderlineWidthValue);
5665 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5667 borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5668 DALI_TEST_CHECK(borderlineColorValue);
5669 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5671 borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5672 DALI_TEST_CHECK(borderlineOffsetValue);
5673 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5677 Renderer renderer = dummyControl.GetRendererAt(0);
5678 Shader shader = renderer.GetShader();
5679 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5680 Property::Map* map = value.GetMap();
5681 DALI_TEST_CHECK(map);
5683 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5684 DALI_TEST_CHECK(fragment);
5685 std::string fragmentShader;
5686 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5687 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5688 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5689 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5691 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5692 std::string vertexShader;
5693 DALI_TEST_CHECK(vertex->Get(vertexShader));
5694 // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5695 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5696 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5699 // Send shader compile signal
5700 application.SendNotification();
5701 application.Render();
5703 callStack.Enable(false);
5704 // Shader not changed
5705 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5710 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5712 ToolkitTestApplication application;
5713 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5715 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5717 VisualFactory factory = VisualFactory::Get();
5718 Property::Map propertyMap;
5720 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
5721 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5723 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5725 DummyControl dummyControl = DummyControl::New(true);
5726 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5727 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5728 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5729 application.GetScene().Add(dummyControl);
5731 application.SendNotification();
5732 application.Render();
5734 // Wait for image loading
5735 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5737 application.SendNotification();
5738 application.Render();
5742 Renderer renderer = dummyControl.GetRendererAt(0);
5743 Shader shader = renderer.GetShader();
5744 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5745 Property::Map* map = value.GetMap();
5746 DALI_TEST_CHECK(map);
5748 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5749 DALI_TEST_CHECK(fragment);
5750 std::string fragmentShader;
5751 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5752 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5753 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5755 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5756 std::string vertexShader;
5757 DALI_TEST_CHECK(vertex->Get(vertexShader));
5758 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5759 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5762 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5764 Property::Map targetPropertyMap;
5765 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5768 callStack.Enable(true);
5770 // Update Properties with CornerRadius
5771 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5773 Property::Map resultMap;
5774 imageVisual.CreatePropertyMap(resultMap);
5776 // Test property values: they should be updated
5777 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5778 DALI_TEST_CHECK(cornerRadiusValue);
5779 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5783 Renderer renderer = dummyControl.GetRendererAt(0);
5784 Shader shader = renderer.GetShader();
5785 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5786 Property::Map* map = value.GetMap();
5787 DALI_TEST_CHECK(map);
5789 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5790 DALI_TEST_CHECK(fragment);
5791 std::string fragmentShader;
5792 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5793 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5794 // Note : corner radius is zero. so we don't change shader!
5795 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5797 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5798 std::string vertexShader;
5799 DALI_TEST_CHECK(vertex->Get(vertexShader));
5800 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5801 // Note : corner radius is zero. so we don't change shader!
5802 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5805 // Send shader compile signal
5806 application.SendNotification();
5807 application.Render();
5809 callStack.Enable(false);
5811 // Shader doesn't changed
5812 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5814 callStack.Enable(true);
5816 float targetBorderlineWidth = 0.0f;
5817 Vector4 targetBorderlineColor = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5818 float targetBorderlineOffset = -1.0f;
5820 Property::Map targetPropertyMap2;
5821 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
5822 targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR] = targetBorderlineColor;
5823 targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5825 // Update Properties with Borderline
5826 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5828 Property::Map resultMap2;
5829 imageVisual.CreatePropertyMap(resultMap2);
5831 // Test property values: they should be updated
5832 Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5833 DALI_TEST_CHECK(borderlineWidthValue);
5834 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5836 Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5837 DALI_TEST_CHECK(borderlineColorValue);
5838 DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5840 Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5841 DALI_TEST_CHECK(borderlineOffsetValue);
5842 DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5846 Renderer renderer = dummyControl.GetRendererAt(0);
5847 Shader shader = renderer.GetShader();
5848 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5849 Property::Map* map = value.GetMap();
5850 DALI_TEST_CHECK(map);
5852 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5853 DALI_TEST_CHECK(fragment);
5854 std::string fragmentShader;
5855 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5856 // Note : borderline width is zero. so we don't change shader!
5857 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5858 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5860 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5861 std::string vertexShader;
5862 DALI_TEST_CHECK(vertex->Get(vertexShader));
5863 // Note : borderline width is zero. so we don't change shader!
5864 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5865 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5868 // Send shader compile signal
5869 application.SendNotification();
5870 application.Render();
5872 callStack.Enable(false);
5874 // Shader doesn't changed
5875 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5880 int UtcDaliVisualUpdatePropertyChangeShader03(void)
5882 ToolkitTestApplication application;
5883 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
5885 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5887 VisualFactory factory = VisualFactory::Get();
5888 Property::Map propertyMap;
5890 propertyMap[Visual::Property::TYPE] = Visual::Type::COLOR;
5891 propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
5893 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5895 DummyControl dummyControl = DummyControl::New(true);
5896 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5897 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5898 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5899 application.GetScene().Add(dummyControl);
5901 application.SendNotification();
5902 application.Render();
5904 application.SendNotification();
5905 application.Render();
5909 Renderer renderer = dummyControl.GetRendererAt(0);
5910 Shader shader = renderer.GetShader();
5911 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5912 Property::Map* map = value.GetMap();
5913 DALI_TEST_CHECK(map);
5915 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5916 DALI_TEST_CHECK(fragment);
5917 std::string fragmentShader;
5918 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5919 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
5920 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5921 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5923 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5924 std::string vertexShader;
5925 DALI_TEST_CHECK(vertex->Get(vertexShader));
5926 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
5927 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5928 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5931 float targetBlurRadius = 15.0f;
5932 Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
5934 Property::Map targetPropertyMap;
5935 targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
5936 targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5937 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
5940 callStack.Enable(true);
5942 // Update Properties with CornerRadius
5943 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5945 Property::Map resultMap;
5946 imageVisual.CreatePropertyMap(resultMap);
5948 // Test property values: they should be updated
5949 Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5950 DALI_TEST_CHECK(blurRadiusValue);
5951 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5953 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5954 DALI_TEST_CHECK(cornerRadiusValue);
5955 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5959 Renderer renderer = dummyControl.GetRendererAt(0);
5960 Shader shader = renderer.GetShader();
5961 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
5962 Property::Map* map = value.GetMap();
5963 DALI_TEST_CHECK(map);
5965 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5966 DALI_TEST_CHECK(fragment);
5967 std::string fragmentShader;
5968 DALI_TEST_CHECK(fragment->Get(fragmentShader));
5969 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
5970 // Note : We ignore borderline when blur radius occured
5971 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5972 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5974 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5975 std::string vertexShader;
5976 DALI_TEST_CHECK(vertex->Get(vertexShader));
5977 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
5978 // Note : We ignore borderline when blur radius occured
5979 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5980 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5983 // Send shader compile signal
5984 application.SendNotification();
5985 application.Render();
5987 callStack.Enable(false);
5990 DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
5992 callStack.Enable(true);
5994 Property::Map targetPropertyMap2;
5995 targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
5996 targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS] = Vector4::ZERO;
5997 targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
5999 // Update Properties with CornerRadius
6000 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6002 Property::Map resultMap2;
6003 imageVisual.CreatePropertyMap(resultMap2);
6005 // Test property values: they should be updated
6006 blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6007 DALI_TEST_CHECK(blurRadiusValue);
6008 DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6010 cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6011 DALI_TEST_CHECK(cornerRadiusValue);
6012 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6016 Renderer renderer = dummyControl.GetRendererAt(0);
6017 Shader shader = renderer.GetShader();
6018 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6019 Property::Map* map = value.GetMap();
6020 DALI_TEST_CHECK(map);
6022 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6023 DALI_TEST_CHECK(fragment);
6024 std::string fragmentShader;
6025 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6026 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6027 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6028 // Note : We ignore borderline when blur radius occured
6029 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6030 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6032 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6033 std::string vertexShader;
6034 DALI_TEST_CHECK(vertex->Get(vertexShader));
6035 // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6036 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6037 // Note : We ignore borderline when blur radius occured
6038 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6039 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6042 // Send shader compile signal
6043 application.SendNotification();
6044 application.Render();
6046 callStack.Enable(false);
6048 // Shader not changed
6049 DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6054 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6056 ToolkitTestApplication application;
6057 tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6059 TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6061 VisualFactory factory = VisualFactory::Get();
6062 Property::Map propertyMap;
6064 propertyMap[Visual::Property::TYPE] = Visual::Type::IMAGE;
6065 propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6066 propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6068 Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6070 DummyControl dummyControl = DummyControl::New(true);
6071 Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6072 dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6073 dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6074 application.GetScene().Add(dummyControl);
6076 application.SendNotification();
6077 application.Render();
6079 // Wait for image loading
6080 DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6082 application.SendNotification();
6083 application.Render();
6087 Renderer renderer = dummyControl.GetRendererAt(0);
6088 Shader shader = renderer.GetShader();
6089 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6090 Property::Map* map = value.GetMap();
6091 DALI_TEST_CHECK(map);
6093 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6094 DALI_TEST_CHECK(fragment);
6095 std::string fragmentShader;
6096 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6097 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6098 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6100 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6101 std::string vertexShader;
6102 DALI_TEST_CHECK(vertex->Get(vertexShader));
6103 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6104 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6107 callStack.Enable(true);
6109 Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6111 Animation animation = Animation::New(1.0f);
6112 animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6115 application.SendNotification();
6116 application.Render();
6117 application.Render(1001u); // End of animation
6121 Renderer renderer = dummyControl.GetRendererAt(0);
6122 Shader shader = renderer.GetShader();
6123 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6124 Property::Map* map = value.GetMap();
6125 DALI_TEST_CHECK(map);
6127 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6128 DALI_TEST_CHECK(fragment);
6129 std::string fragmentShader;
6130 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6131 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6132 // Note : mAlwaysUsingCornerRadius is true.
6133 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6135 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6136 std::string vertexShader;
6137 DALI_TEST_CHECK(vertex->Get(vertexShader));
6138 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6139 // Note : mAlwaysUsingCornerRadius is true.
6140 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6142 callStack.Enable(false);
6143 // Shader not changed
6144 DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6146 callStack.Enable(true);
6148 float targetBorderlineWidth = 10.0f;
6149 Property::Map targetPropertyMap;
6150 targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6152 // Update Properties with CornerRadius
6153 DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6155 Property::Map resultMap;
6156 imageVisual.CreatePropertyMap(resultMap);
6158 // Test property values: they should be updated
6159 Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6160 DALI_TEST_CHECK(cornerRadiusValue);
6161 DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6163 Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6164 DALI_TEST_CHECK(cornerRadiusPolicyValue);
6165 DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6167 Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6168 DALI_TEST_CHECK(borderlineWidthValue);
6169 DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6173 Renderer renderer = dummyControl.GetRendererAt(0);
6174 Shader shader = renderer.GetShader();
6175 Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
6176 Property::Map* map = value.GetMap();
6177 DALI_TEST_CHECK(map);
6179 Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6180 DALI_TEST_CHECK(fragment);
6181 std::string fragmentShader;
6182 DALI_TEST_CHECK(fragment->Get(fragmentShader));
6183 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6184 // Note : mAlwaysUsingCornerRadius is true.
6185 DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6187 Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6188 std::string vertexShader;
6189 DALI_TEST_CHECK(vertex->Get(vertexShader));
6190 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6191 // Note : mAlwaysUsingCornerRadius is true.
6192 DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6195 // Send shader compile signal
6196 application.SendNotification();
6197 application.Render();
6199 callStack.Enable(false);
6201 DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));