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