[dali_1.9.0] Merge branch 'devel/master' 58/225658/1
authorCheng-Shiun Tsai <cheng.tsai@samsung.com>
Fri, 21 Feb 2020 16:25:51 +0000 (16:25 +0000)
committerCheng-Shiun Tsai <cheng.tsai@samsung.com>
Fri, 21 Feb 2020 16:25:51 +0000 (16:25 +0000)
Change-Id: I7dfab44f0a06331de246479f0087ebffb67b88d6

45 files changed:
automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp
automated-tests/src/dali-toolkit/utc-Dali-FlexNode.cpp
automated-tests/src/dali-toolkit/utc-Dali-ImageView.cpp
automated-tests/src/dali-toolkit/utc-Dali-Visual.cpp
automated-tests/src/dali-toolkit/utc-Dali-VisualFactory.cpp
dali-toolkit/devel-api/layouting/flex-node.cpp
dali-toolkit/devel-api/layouting/flex-node.h
dali-toolkit/devel-api/visuals/visual-properties-devel.h
dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.cpp
dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
dali-toolkit/internal/visuals/animated-image/fixed-image-cache.cpp
dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h
dali-toolkit/internal/visuals/animated-image/rolling-image-cache.cpp
dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h
dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
dali-toolkit/internal/visuals/border/border-visual.cpp
dali-toolkit/internal/visuals/color/color-visual.cpp
dali-toolkit/internal/visuals/gradient/gradient-visual.cpp
dali-toolkit/internal/visuals/gradient/gradient.cpp
dali-toolkit/internal/visuals/image-visual-shader-factory.cpp
dali-toolkit/internal/visuals/image-visual-shader-factory.h
dali-toolkit/internal/visuals/image/image-visual.cpp
dali-toolkit/internal/visuals/image/image-visual.h
dali-toolkit/internal/visuals/mesh/mesh-visual.cpp
dali-toolkit/internal/visuals/npatch-loader.cpp
dali-toolkit/internal/visuals/npatch-loader.h
dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
dali-toolkit/internal/visuals/npatch/npatch-visual.h
dali-toolkit/internal/visuals/primitive/primitive-visual.cpp
dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp
dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h
dali-toolkit/internal/visuals/svg/svg-visual.cpp
dali-toolkit/internal/visuals/text/text-visual.cpp
dali-toolkit/internal/visuals/texture-manager-impl.cpp
dali-toolkit/internal/visuals/texture-manager-impl.h
dali-toolkit/internal/visuals/texture-upload-observer.h
dali-toolkit/internal/visuals/visual-base-data-impl.cpp
dali-toolkit/internal/visuals/visual-base-data-impl.h
dali-toolkit/internal/visuals/visual-base-impl.cpp
dali-toolkit/internal/visuals/visual-base-impl.h
dali-toolkit/internal/visuals/visual-factory-cache.h
dali-toolkit/internal/visuals/visual-string-constants.cpp
dali-toolkit/internal/visuals/visual-string-constants.h
dali-toolkit/public-api/dali-toolkit-version.cpp
packaging/dali-toolkit.spec

index 823c7bb..21f6f7c 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53,6 +53,12 @@ public:
     mObserverCalled = true;
   }
 
+  virtual void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied ) override
+  {
+    mLoaded = loadSuccess;
+    mObserverCalled = true;
+  }
+
   bool mLoaded;
   bool mObserverCalled;
 };
index 3d54ae2..31a6bf2 100755 (executable)
@@ -63,6 +63,36 @@ int UtcDaliToolkitFlexNodeConstructorP(void)
   END_TEST;
 }
 
+int UtcDaliToolkitFlexNodeAddChildWithMarginP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliToolkitFlexNodeAddChildWithMarginP");
+  Flex::Node* flexNode = new Flex::Node();
+  DALI_TEST_CHECK( flexNode );
+
+  // Position elements as a Row
+  flexNode->SetFlexDirection(Flex::FlexDirection::ROW);
+
+  // Create two actors and add them to the parent flex node
+  Actor actor = Actor::New();
+  DALI_TEST_CHECK( actor );
+
+  Extents margin( 5,5,5,5);
+  flexNode->AddChild(actor, margin, &MeasureChild, 0);
+
+  DALI_TEST_EQUALS( (int)flexNode->GetFlexDirection(), (int)Flex::FlexDirection::ROW, TEST_LOCATION );
+
+  flexNode->CalculateLayout(480, 800, false);
+
+  Vector4 actorFrame = flexNode->GetNodeFrame(0);
+
+  tet_printf("Actor frame(left:%f,top:%f,right:%f,bottom:%f)\n", actorFrame.x, actorFrame.y, actorFrame.z, actorFrame.w);
+
+  DALI_TEST_EQUALS( actorFrame, Vector4( 5.0f, 5.0f, ITEM_SIZE.width+5, ITEM_SIZE.height+5 ), TEST_LOCATION );
+
+  END_TEST;
+}
+
 int UtcDaliToolkitFlexNodeAddChildrenRowP(void)
 {
   ToolkitTestApplication application;
@@ -79,8 +109,8 @@ int UtcDaliToolkitFlexNodeAddChildrenRowP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   DALI_TEST_EQUALS( (int)flexNode->GetFlexDirection(), (int)Flex::FlexDirection::ROW, TEST_LOCATION );
 
@@ -114,8 +144,8 @@ int UtcDaliToolkitFlexNodeAddChildrenColumnP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
@@ -158,8 +188,8 @@ int UtcDaliToolkitFlexNodeAddChildrenColumnJustify(void)
   DALI_TEST_EQUALS( (int)flexNode->GetFlexJustification(), (int)Flex::Justification::FLEX_START, TEST_LOCATION );
   DALI_TEST_EQUALS( (int)flexNode->GetFlexItemsAlignment(), (int)Flex::Alignment::FLEX_START, TEST_LOCATION );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
@@ -256,8 +286,8 @@ int UtcDaliToolkitFlexNodeSizingP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
@@ -290,10 +320,10 @@ int UtcDaliToolkitFlexNodeWrapModeP(void)
   DALI_TEST_EQUALS( (int)flexNode->GetFlexAlignment(), (int)Flex::Alignment::FLEX_START, TEST_LOCATION );
   DALI_TEST_EQUALS( (int)flexNode->GetFlexWrap(), (int)Flex::WrapType::NO_WRAP, TEST_LOCATION );
 
-  flexNode->AddChild( actor1, &MeasureChild, 0 );
-  flexNode->AddChild( actor2, &MeasureChild, 1 );
-  flexNode->AddChild( actor2, &MeasureChild, 2 );
-  flexNode->AddChild( actor2, &MeasureChild, 3 );
+  flexNode->AddChild( actor1, Extents(0,0,0,0), &MeasureChild, 0 );
+  flexNode->AddChild( actor2, Extents(0,0,0,0), &MeasureChild, 1 );
+  flexNode->AddChild( actor2, Extents(0,0,0,0), &MeasureChild, 2 );
+  flexNode->AddChild( actor2, Extents(0,0,0,0), &MeasureChild, 3 );
 
   flexNode->CalculateLayout(30, 800, false);
 
@@ -377,8 +407,8 @@ int UtcDaliToolkitFlexNodeRemoveChildP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
@@ -420,8 +450,8 @@ int UtcDaliToolkitFlexNodeRemoveAllChildrenP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
@@ -462,8 +492,8 @@ int UtcDaliToolkitFlexNodePaddingMarginP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   Extents padding( 5,5,5,5);
   Extents margin( 5,5,5,5);
@@ -509,8 +539,8 @@ int UtcDaliToolkitFlexNodeCallbackTestP(void)
   DALI_TEST_CHECK( actor1 );
   DALI_TEST_CHECK( actor2 );
 
-  flexNode->AddChild(actor1, &MeasureChild, 0);
-  flexNode->AddChild(actor2, &MeasureChild, 1);
+  flexNode->AddChild(actor1, Extents(0,0,0,0), &MeasureChild, 0);
+  flexNode->AddChild(actor2, Extents(0,0,0,0), &MeasureChild, 1);
 
   flexNode->CalculateLayout(480, 800, false);
 
index a59b0ff..4e72473 100644 (file)
@@ -2432,6 +2432,122 @@ int UtcDaliImageViewLoadRemoteSVG(void)
   END_TEST;
 }
 
+int UtcDaliImageViewSyncSVGLoading(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("ImageView Testing SVG image sync loading");
+
+  // Sync loading, automatic atlasing for small size image
+  {
+    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
+    callStack.Reset();
+    callStack.Enable(true);
+
+    ImageView imageView = ImageView::New( );
+
+    // Sync loading is used
+    Property::Map syncLoadingMap;
+    syncLoadingMap.Insert( Toolkit::Visual::Property::TYPE,  Toolkit::Visual::IMAGE );
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::URL,  TEST_RESOURCE_DIR "/svg1.svg"  );
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING,  true);
+    imageView.SetProperty( ImageView::Property::IMAGE, syncLoadingMap );
+
+    Stage::GetCurrent().Add( imageView );
+    DALI_TEST_CHECK( imageView );
+
+    application.SendNotification();
+    application.Render(16);
+    Vector3 naturalSize = imageView.GetNaturalSize();
+
+    DALI_TEST_EQUALS( naturalSize.width, 100.0f, TEST_LOCATION );
+    DALI_TEST_EQUALS( naturalSize.height, 100.0f, TEST_LOCATION );
+
+  }
+  END_TEST;
+}
+
+int UtcDaliImageViewAsyncSVGLoading(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("ImageView Testing SVG image async loading");
+
+  // Sync loading, automatic atlasing for small size image
+  {
+    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
+    callStack.Reset();
+    callStack.Enable(true);
+
+    ImageView imageView = ImageView::New( );
+
+    // Sync loading is used
+    Property::Map syncLoadingMap;
+    syncLoadingMap.Insert( Toolkit::Visual::Property::TYPE,  Toolkit::Visual::IMAGE );
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::URL,  TEST_RESOURCE_DIR "/svg1.svg"  );
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING,  false);
+    imageView.SetProperty( ImageView::Property::IMAGE, syncLoadingMap );
+
+    Stage::GetCurrent().Add( imageView );
+    DALI_TEST_CHECK( imageView );
+
+    application.SendNotification();
+    application.Render(16);
+    Vector3 naturalSize = imageView.GetNaturalSize();
+
+    DALI_TEST_EQUALS( naturalSize.width, 100.0f, TEST_LOCATION );
+    DALI_TEST_EQUALS( naturalSize.height, 100.0f, TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliImageViewSVGLoadingSyncSetInvalidValue(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("ImageView Testing SVG image async loading");
+
+  // Sync loading, automatic atlasing for small size image
+  {
+    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
+    callStack.Reset();
+    callStack.Enable(true);
+
+    ImageView imageView = ImageView::New( );
+
+    // Sync loading is used
+    Property::Map syncLoadingMap;
+    syncLoadingMap.Insert( Toolkit::Visual::Property::TYPE,  Toolkit::Visual::IMAGE );
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::URL,  TEST_RESOURCE_DIR "/svg1.svg"  );
+
+    // Check to set invalid value
+    // The SYNCHRONOUS_LOADING property must be set to the bool value.
+    // Check if error log is outputted when setting other value like string.
+    // Even if the wrong value is set, the image will be shown normally, and the synchronous value should be the default value(false).
+    syncLoadingMap.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, std::to_string(5) );
+    imageView.SetProperty( ImageView::Property::IMAGE, syncLoadingMap );
+
+    Stage::GetCurrent().Add( imageView );
+    DALI_TEST_CHECK( imageView );
+
+    application.SendNotification();
+    application.Render(16);
+    Vector3 naturalSize = imageView.GetNaturalSize();
+    DALI_TEST_EQUALS( naturalSize.width, 100.0f, TEST_LOCATION );
+    DALI_TEST_EQUALS( naturalSize.height, 100.0f, TEST_LOCATION );
+
+    Property::Value value = imageView.GetProperty( ImageView::Property::IMAGE );
+    Property::Map* map = value.GetMap();
+    DALI_TEST_CHECK( map );
+
+    Property::Value* sync = map->Find( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING );
+    DALI_TEST_CHECK( sync );
+    DALI_TEST_EQUALS( false, sync->Get< bool >(), TEST_LOCATION );
+
+  }
+  END_TEST;
+}
+
 int UtcDaliImageViewSvgLoadingFailure(void)
 {
   ToolkitTestApplication application;
index d1df2ac..d26b857 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -508,6 +508,7 @@ int UtcDaliVisualGetPropertyMap1(void)
   Property::Map propertyMap;
   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
   propertyMap.Insert(Visual::Property::MIX_COLOR,  Color::BLUE);
+  propertyMap.Insert( DevelVisual::Property::CORNER_RADIUS, 10.0f );
   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 
   Property::Map resultMap;
@@ -521,6 +522,10 @@ int UtcDaliVisualGetPropertyMap1(void)
   DALI_TEST_CHECK( colorValue );
   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 
+  Property::Value* radiusValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
+  DALI_TEST_CHECK( radiusValue );
+  DALI_TEST_CHECK( radiusValue->Get< float >() == 10.0f );
+
   // change the blend color
   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
   colorVisual = factory.CreateVisual( propertyMap  );
@@ -2977,8 +2982,11 @@ int UtcDaliVisualSetTransform7(void)
   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
 
   VisualFactory factory = VisualFactory::Get();
-  Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
-  Visual::Base visual = factory.CreateVisual(image);
+  Property::Map propertyMap;
+  propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
+  propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
+  propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
+  Visual::Base visual = factory.CreateVisual(propertyMap);
   TestTransform( application, visual );
   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
 
@@ -3048,6 +3056,7 @@ int UtcDaliNPatchVisualCustomShader(void)
   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
   properties[Visual::Property::SHADER]=shader;
   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
+  properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
 
   Visual::Base visual = factory.CreateVisual( properties );
   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
@@ -3573,3 +3582,73 @@ int UtcDaliSvgVisualCustomShader(void)
 
   END_TEST;
 }
+
+int UtcDaliVisualRoundedCorner(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcDaliVisualRoundedCorner" );
+
+  // image visual
+  {
+    VisualFactory factory = VisualFactory::Get();
+    Property::Map properties;
+    float cornerRadius = 30.0f;
+
+    properties[Visual::Property::TYPE] = Visual::IMAGE;
+    properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
+    properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
+
+    Visual::Base visual = factory.CreateVisual( properties );
+
+    // trigger creation through setting on stage
+    DummyControl dummy = DummyControl::New( true );
+    Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
+    dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+    dummy.SetSize( 200.f, 200.f );
+    dummy.SetParentOrigin( ParentOrigin::CENTER );
+    Stage::GetCurrent().Add( dummy );
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+  }
+
+  // color visual
+  {
+    VisualFactory factory = VisualFactory::Get();
+    Property::Map properties;
+    float cornerRadius = 30.0f;
+
+    properties[Visual::Property::TYPE] = Visual::COLOR;
+    properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
+    properties["cornerRadius"] = cornerRadius;
+
+    Visual::Base visual = factory.CreateVisual( properties );
+
+    // trigger creation through setting on stage
+    DummyControl dummy = DummyControl::New( true );
+    Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
+    dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+    dummy.SetSize( 200.f, 200.f );
+    dummy.SetParentOrigin( ParentOrigin::CENTER );
+    Stage::GetCurrent().Add( dummy );
+
+    application.SendNotification();
+    application.Render();
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
index 69df067..df2d7be 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,8 @@
 #include <dali/devel-api/adaptor-framework/image-loading.h>
 #include "dummy-control.h"
 
+#include <dali/integration-api/debug.h>
+
 using namespace Dali;
 using namespace Dali::Toolkit;
 
@@ -84,6 +86,29 @@ void TestVisualRender( ToolkitTestApplication& application,
   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 }
 
+void TestVisualAsynchronousRender( ToolkitTestApplication& application,
+                                   DummyControl& actor,
+                                   Visual::Base& visual )
+{
+  DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
+  dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+  actor.SetSize( 200.f, 200.f );
+  DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
+  Stage::GetCurrent().Add( actor );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+}
+
 } // namespace
 
 
@@ -439,10 +464,10 @@ int UtcDaliVisualFactoryDefaultOffsetsGradientVisual(void)
   END_TEST;
 }
 
-int UtcDaliVisualFactoryGetNPatchVisual1(void)
+int UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad1(void)
 {
   ToolkitTestApplication application;
-  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual1: Request 9-patch visual with a Property::Map" );
+  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad1: Request 9-patch visual with a Property::Map" );
 
   VisualFactory factory = VisualFactory::Get();
   DALI_TEST_CHECK( factory );
@@ -453,6 +478,7 @@ int UtcDaliVisualFactoryGetNPatchVisual1(void)
   Property::Map propertyMap;
   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
   propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
+  propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
   {
     tet_infoline( "whole grid" );
     Visual::Base visual = factory.CreateVisual( propertyMap );
@@ -495,10 +521,10 @@ int UtcDaliVisualFactoryGetNPatchVisual1(void)
   END_TEST;
 }
 
-int UtcDaliVisualFactoryGetNPatchVisual2(void)
+int UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad2(void)
 {
   ToolkitTestApplication application;
-  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual1: Request 9-patch visual with a Property::Map including border" );
+  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad2: Request 9-patch visual with a Property::Map including border" );
 
   VisualFactory factory = VisualFactory::Get();
   DALI_TEST_CHECK( factory );
@@ -510,6 +536,7 @@ int UtcDaliVisualFactoryGetNPatchVisual2(void)
   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 2, 2, 2, 2 ) );
+  propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
   {
     tet_infoline( "whole grid" );
     Visual::Base visual = factory.CreateVisual( propertyMap );
@@ -553,6 +580,147 @@ int UtcDaliVisualFactoryGetNPatchVisual2(void)
   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 1, 1, 1, 1 ) );
+  propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
+  {
+    tet_infoline( "whole grid" );
+    Visual::Base visual = factory.CreateVisual( propertyMap );
+    DALI_TEST_CHECK( visual );
+
+    TestGlAbstraction& gl = application.GetGlAbstraction();
+    TraceCallStack& textureTrace = gl.GetTextureTrace();
+    textureTrace.Enable(true);
+
+    DummyControl actor = DummyControl::New(true);
+    TestVisualRender( application, actor, visual );
+
+    DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
+
+    Vector2 naturalSize( 0.0f, 0.0f );
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliVisualFactoryGetNPatchVisual1(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual1: Request 9-patch visual with a Property::Map" );
+
+  VisualFactory factory = VisualFactory::Get();
+  DALI_TEST_CHECK( factory );
+
+  // Get actual size of test image
+  ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
+
+  Property::Map propertyMap;
+  propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
+  propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
+  propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, false );
+  {
+    tet_infoline( "whole grid" );
+    Visual::Base visual = factory.CreateVisual( propertyMap );
+    DALI_TEST_CHECK( visual );
+
+    Vector2 naturalSize( 0.0f, 0.0f );
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
+
+    TestGlAbstraction& gl = application.GetGlAbstraction();
+    TraceCallStack& textureTrace = gl.GetTextureTrace();
+    textureTrace.Enable(true);
+
+    DummyControl actor = DummyControl::New(true);
+    TestVisualAsynchronousRender( application, actor, visual );
+
+    DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
+
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
+  }
+
+  propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
+  {
+    tet_infoline( "border only" );
+    Visual::Base visual = factory.CreateVisual( propertyMap );
+    DALI_TEST_CHECK( visual );
+
+    TestGlAbstraction& gl = application.GetGlAbstraction();
+    TraceCallStack& textureTrace = gl.GetTextureTrace();
+    textureTrace.Enable(true);
+
+    DummyControl actor = DummyControl::New(true);
+    TestVisualRender( application, actor, visual );
+
+    DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
+
+    Vector2 naturalSize( 0.0f, 0.0f );
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliVisualFactoryGetNPatchVisual2(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual2: Request 9-patch visual with a Property::Map including border" );
+
+  VisualFactory factory = VisualFactory::Get();
+  DALI_TEST_CHECK( factory );
+
+  // Get actual size of test image
+  ImageDimensions imageSize = Dali::GetClosestImageSize( gImage_34_RGBA );
+
+  Property::Map propertyMap;
+  propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
+  propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
+  propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 2, 2, 2, 2 ) );
+  {
+    tet_infoline( "whole grid" );
+    Visual::Base visual = factory.CreateVisual( propertyMap );
+    DALI_TEST_CHECK( visual );
+
+    TestGlAbstraction& gl = application.GetGlAbstraction();
+    TraceCallStack& textureTrace = gl.GetTextureTrace();
+    textureTrace.Enable(true);
+
+    DummyControl actor = DummyControl::New(true);
+    TestVisualAsynchronousRender( application, actor, visual );
+
+    DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
+
+    Vector2 naturalSize( 0.0f, 0.0f );
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
+  }
+
+  propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
+  {
+    tet_infoline( "border only" );
+    Visual::Base visual = factory.CreateVisual( propertyMap );
+    DALI_TEST_CHECK( visual );
+
+    TestGlAbstraction& gl = application.GetGlAbstraction();
+    TraceCallStack& textureTrace = gl.GetTextureTrace();
+    textureTrace.Enable(true);
+
+    DummyControl actor = DummyControl::New(true);
+    TestVisualRender( application, actor, visual );
+
+    DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
+
+    Vector2 naturalSize( 0.0f, 0.0f );
+    visual.GetNaturalSize( naturalSize );
+    DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
+  }
+
+  propertyMap.Clear();
+  propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
+  propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
+  propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 1, 1, 1, 1 ) );
   {
     tet_infoline( "whole grid" );
     Visual::Base visual = factory.CreateVisual( propertyMap );
@@ -598,7 +766,7 @@ int UtcDaliVisualFactoryGetNPatchVisual3(void)
     textureTrace.Enable(true);
 
     DummyControl actor = DummyControl::New(true);
-    TestVisualRender( application, actor, visual );
+    TestVisualAsynchronousRender( application, actor, visual );
 
     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -652,9 +820,8 @@ int UtcDaliVisualFactoryGetNPatchVisual4(void)
   TestGlAbstraction& gl = application.GetGlAbstraction();
   TraceCallStack& textureTrace = gl.GetTextureTrace();
   textureTrace.Enable(true);
-
   DummyControl actor = DummyControl::New(true);
-  TestVisualRender( application, actor, visual );
+  TestVisualAsynchronousRender( application, actor, visual );
 
   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -698,7 +865,7 @@ int UtcDaliVisualFactoryGetNPatchVisual5(void)
   textureTrace.Enable(true);
 
   DummyControl actor = DummyControl::New(true);
-  TestVisualRender( application, actor, visual );
+  TestVisualAsynchronousRender( application, actor, visual );
 
   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -733,7 +900,7 @@ int UtcDaliVisualFactoryGetNPatchVisual6(void)
     textureTrace.Enable(true);
 
     DummyControl actor = DummyControl::New(true);
-    TestVisualRender( application, actor, visual );
+    TestVisualAsynchronousRender( application, actor, visual );
 
     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -761,7 +928,7 @@ int UtcDaliVisualFactoryGetNPatchVisual6(void)
     textureTrace.Enable(true);
 
     DummyControl actor = DummyControl::New(true);
-    TestVisualRender( application, actor, visual );
+    TestVisualAsynchronousRender( application, actor, visual );
 
     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -810,6 +977,12 @@ int UtcDaliNPatchVisualAuxiliaryImage(void)
   dummy.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
   dummy.SetParentOrigin(ParentOrigin::CENTER);
   Stage::GetCurrent().Add(dummy);
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
@@ -839,7 +1012,7 @@ int UtcDaliVisualFactoryGetNPatchVisualN1(void)
   textureTrace.Enable(true);
 
   DummyControl actor = DummyControl::New(true);
-  TestVisualRender( application, actor, visual );
+  TestVisualAsynchronousRender( application, actor, visual );
 
   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
@@ -870,7 +1043,7 @@ int UtcDaliVisualFactoryGetNPatchVisualN2(void)
   drawTrace.Enable(true);
 
   DummyControl actor = DummyControl::New(true);
-  TestVisualRender( application, actor, visual );
+  TestVisualAsynchronousRender( application, actor, visual );
 
   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 
index 189ab8a..f13549c 100644 (file)
@@ -101,7 +101,7 @@ Node::~Node()
   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Destructor() <<\n");
 }
 
-void Node::AddChild( Actor child, MeasureCallback measureFunction, int index )
+void Node::AddChild( Actor child, Extents margin, MeasureCallback measureFunction, int index )
 {
   if( child )
   {
@@ -115,11 +115,17 @@ void Node::AddChild( Actor child, MeasureCallback measureFunction, int index )
     childNode->mImpl->mActor = child;
     Vector2 minumumSize = child.GetMinimumSize();
     Vector2 maximumSize = child.GetMaximumSize();
+
     YGNodeStyleSetMaxWidth( childNode->mImpl->mYogaNode, maximumSize.width );
     YGNodeStyleSetMaxHeight( childNode->mImpl->mYogaNode, maximumSize.height );
     YGNodeStyleSetMinWidth( childNode->mImpl->mYogaNode, minumumSize.width );
     YGNodeStyleSetMinHeight( childNode->mImpl->mYogaNode, minumumSize.height );
 
+    YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeLeft, margin.start );
+    YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeTop, margin.top );
+    YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeRight, margin.end );
+    YGNodeStyleSetMargin( childNode->mImpl->mYogaNode, YGEdgeBottom, margin.bottom );
+
     YGNodeSetMeasureFunc( childNode->mImpl->mYogaNode, &MeasureChild );
 
     YGNodeInsertChild( mImpl->mYogaNode, childNode->mImpl->mYogaNode, index );
index 034e555..1b76f76 100644 (file)
@@ -130,10 +130,11 @@ public:
   /**
    * @brief Insert child into the FlexLayout at the given index.
    * @param[in] child Actor to insert.
+   * @param[in] margin of child Actor.
    * @param[in] measureFunction for the child.
    * @param[in] index to insert at.
    */
-  void AddChild( Actor child, MeasureCallback measureFunction, int index );
+  void AddChild( Actor child, Extents margin, MeasureCallback measureFunction, int index );
 
   /**
    * @brief Remove child from the FlexLayout at the given index.
index 709b12a..5958037 100644 (file)
@@ -72,6 +72,13 @@ enum Type
    * @note The default is defined by the type of visual (if it's suitable to be stretched or not).
    */
   VISUAL_FITTING_MODE = OPACITY + 1,
+
+  /**
+   * @brief The radius for the rounded corners of the visual
+   * @details Name "cornerRadius", type Property::FLOAT or Property::VECTOR4.
+   * @note Optional.
+   */
+  CORNER_RADIUS = OPACITY + 2,
 };
 
 } // namespace Property
index 1a624c4..d4e2f6e 100755 (executable)
@@ -37,37 +37,6 @@ namespace Internal
 
 namespace
 {
-// non-animated property
-const char* const GRADIENT_TYPE_NAME("gradientType");
-const char* const UNIT_TYPE_NAME("unitType");
-const char* const SPREAD_TYPE_NAME("spreadType");
-// animated property
-const char* const START_POSITION_NAME("startPosition");
-const char* const START_COLOR_NAME("startColor");
-const char* const END_POSITION_NAME("endPosition");
-const char* const END_COLOR_NAME("endColor");
-const char* const ROTATE_CENTER_NAME("rotateCenter");
-const char* const ROTATE_AMOUNT_NAME("rotateAmount");
-const char* const OFFSET_NAME("offset");
-// animation parameter property
-const char* const START_VALUE_NAME("startValue");
-const char* const TARGET_VALUE_NAME("targetValue");
-const char* const DIRECTION_TYPE_NAME("directionType");
-const char* const DURATION_NAME("duration");
-const char* const DELAY_NAME("delay");
-const char* const REPEAT_NAME("repeat");
-const char* const REPEAT_DELAY_NAME("repeatDelay");
-const char* const MOTION_TYPE_NAME("motionType");
-const char* const EASING_TYPE_NAME("easingType");
-// common shader property
-const char* const UNIFORM_START_POINT_NAME("start_point");
-const char* const UNIFORM_START_COLOR_NAME("start_color");
-const char* const UNIFORM_END_POINT_NAME("end_point");
-const char* const UNIFORM_END_COLOR_NAME("end_color");
-const char* const UNIFORM_ROTATE_CENTER_NAME("rotate_center");
-const char* const UNIFORM_ROTATE_ANGLE_NAME("rotate_angle");
-const char* const UNIFORM_OFFSET_NAME("gradient_offset");
-
 DALI_ENUM_TO_STRING_TABLE_BEGIN( GRADIENT_TYPE )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::DevelAnimatedGradientVisual::GradientType, LINEAR )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::DevelAnimatedGradientVisual::GradientType, RADIAL )
index a1c9331..f2160ef 100755 (executable)
@@ -444,7 +444,7 @@ void AnimatedImageVisual::CreateRenderer()
 {
   bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
   bool atlasing = false;
-  Shader shader = mImageVisualShaderFactory.GetShader( mFactoryCache, atlasing, defaultWrapMode );
+  Shader shader = mImageVisualShaderFactory.GetShader( mFactoryCache, atlasing, defaultWrapMode, IsRoundedCornerRequired() );
 
   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 
index e64a51b..9acf1af 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -190,6 +190,17 @@ void FixedImageCache::UploadComplete(
   }
 }
 
+void FixedImageCache::LoadComplete(
+  bool loadSuccess,
+  Devel::PixelBuffer pixelBuffer,
+  const VisualUrl& url,
+  bool preMultiplied )
+{
+  // LoadComplete is called if this TextureUploadObserver requested to load
+  // an image that will be returned as a type of PixelBuffer by using a method
+  // TextureManager::LoadPixelBuffer.
+}
+
 } //namespace Internal
 } //namespace Toolkit
-} //namespace Dali
+} //namespace Dali
\ No newline at end of file
index ceb9fff..72484a4 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_FIXED_IMAGE_CACHE_H
 
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -96,7 +96,13 @@ protected:
     TextureSet     textureSet,
     bool           useAtlasing,
     const Vector4& atlasRect,
-    bool           premultiplied) override;
+    bool           premultiplied ) override;
+
+  void LoadComplete(
+    bool loadSuccess,
+    Devel::PixelBuffer pixelBuffer,
+    const VisualUrl& url,
+    bool preMultiplied ) override;
 
 private:
   std::vector<UrlStore>& mImageUrls;
index c39be7e..b7b45ff 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -231,6 +231,17 @@ void RollingImageCache::UploadComplete(
   LOG_CACHE;
 }
 
+void RollingImageCache::LoadComplete(
+  bool loadSuccess,
+  Devel::PixelBuffer pixelBuffer,
+  const VisualUrl& url,
+  bool preMultiplied )
+{
+  // LoadComplete is called if this TextureUploadObserver requested to load
+  // an image that will be returned as a type of PixelBuffer by using a method
+  // TextureManager::LoadPixelBuffer.
+}
+
 } //namespace Internal
 } //namespace Toolkit
 } //namespace Dali
index c5650cf..a0d734d 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_ROLLING_IMAGE_CACHE_H
 
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -114,6 +114,12 @@ protected:
     const Vector4& atlasRect,
     bool           preMultiplied ) override;
 
+  void LoadComplete(
+    bool loadSuccess,
+    Devel::PixelBuffer pixelBuffer,
+    const VisualUrl& url,
+    bool preMultiplied ) override;
+
 private:
   /**
    * Secondary class to hold readiness and index into url
index 2ed0502..9b3fb7e 100644 (file)
@@ -267,7 +267,7 @@ void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
   }
   else
   {
-    shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
+    shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true, false );
   }
 
   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
index d1c3280..a64b48d 100644 (file)
@@ -41,10 +41,6 @@ namespace Internal
 
 namespace
 {
-const char * const COLOR_NAME("borderColor");
-const char * const SIZE_NAME("borderSize");
-const char * const ANTI_ALIASING("antiAliasing");
-
 const char * const POSITION_ATTRIBUTE_NAME("aPosition");
 const char * const DRIFT_ATTRIBUTE_NAME("aDrift");
 const char * const INDEX_NAME("indices");
index 9fa6a30..25ea34b 100644 (file)
@@ -78,6 +78,53 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
     gl_FragColor = vec4(mixColor, 1.0)*uColor;\n
   }\n
 );
+
+const char* VERTEX_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
+  attribute mediump vec2 aPosition;\n
+  uniform highp   mat4 uMvpMatrix;\n
+  uniform mediump vec3 uSize;\n
+  varying mediump vec2 vPosition;\n
+  varying mediump vec2 vRectSize;\n
+  \n
+  //Visual size and offset
+  uniform mediump vec2 offset;\n
+  uniform mediump vec2 size;\n
+  uniform mediump vec4 offsetSizeMode;\n
+  uniform mediump vec2 origin;\n
+  uniform mediump vec2 anchorPoint;\n
+  uniform mediump float cornerRadius;\n
+  \n
+  vec4 ComputeVertexPosition()\n
+  {\n
+    vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
+    vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
+    vRectSize = visualSize / 2.0 - cornerRadius;\n
+    vPosition = aPosition* visualSize;\n
+    return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
+  }\n
+  \n
+  void main()\n
+  {\n
+    gl_Position = uMvpMatrix * ComputeVertexPosition();\n
+  }\n
+);
+
+//float distance = length( max( abs( position - center ), size ) - size ) - radius;
+const char* FRAGMENT_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
+  varying mediump vec2 vPosition;\n
+  varying mediump vec2 vRectSize;\n
+  uniform lowp vec4 uColor;\n
+  uniform lowp vec3 mixColor;\n
+  uniform mediump float cornerRadius;\n
+  \n
+  void main()\n
+  {\n
+      mediump float dist = length( max( abs( vPosition ), vRectSize ) - vRectSize ) - cornerRadius;\n
+      gl_FragColor = uColor * vec4( mixColor, 1.0 );\n
+      gl_FragColor.a *= smoothstep( 1.0, -1.0, dist );\n
+  }\n
+);
+
 }
 
 ColorVisualPtr ColorVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
@@ -175,11 +222,24 @@ void ColorVisual::InitializeRenderer()
 {
   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 
-  Shader shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER );
-  if( !shader )
+  Shader shader;
+  if( !IsRoundedCornerRequired() )
   {
-    shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER, shader );
+    shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER );
+    if( !shader )
+    {
+      shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+      mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER, shader );
+    }
+  }
+  else
+  {
+    shader = mFactoryCache.GetShader( VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER );
+    if( !shader )
+    {
+      shader = Shader::New( VERTEX_SHADER_ROUNDED_CORNER, FRAGMENT_SHADER_ROUNDED_CORNER );
+      mFactoryCache.SaveShader( VisualFactoryCache::COLOR_SHADER_ROUNDED_CORNER, shader );
+    }
   }
 
   mImpl->mRenderer = Renderer::New( geometry, shader );
index 27c12dd..53ea041 100644 (file)
@@ -48,19 +48,6 @@ namespace Internal
 
 namespace
 {
-// properties: linear gradient
-const char * const START_POSITION_NAME("startPosition"); // Property::VECTOR2
-const char * const END_POSITION_NAME("endPosition"); // Property::VECTOR2
-
-// properties: radial gradient
-const char * const CENTER_NAME("center"); // Property::VECTOR2
-const char * const RADIUS_NAME("radius"); // Property::FLOAT
-
-// properties: linear&radial gradient
-const char * const STOP_OFFSET_NAME("stopOffset"); // Property::Array FLOAT
-const char * const STOP_COLOR_NAME("stopColor"); // Property::Array VECTOR4
-const char * const UNITS_NAME("units"); // Property::String  "userSpaceOnUse | objectBoundingBox"
-const char * const SPREAD_METHOD_NAME("spreadMethod"); // Property::String  "pad | reflect | repeat"
 
 DALI_ENUM_TO_STRING_TABLE_BEGIN( UNITS )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::GradientVisual::Units, OBJECT_BOUNDING_BOX )
index 3846911..2c90e52 100644 (file)
@@ -153,7 +153,7 @@ Dali::Texture Gradient::GenerateLookupTexture()
 
     for( int j = segmentStart; j<segmentEnd; j++ )
     {
-      float ratio = static_cast<float>(j-segmentStart)/segmentWidth;
+      float ratio = static_cast<float>(j-segmentStart)/(segmentWidth - 1);
       Vector4 currentColor = mGradientStops[i].mStopColor * (1.f-ratio) + mGradientStops[i+1].mStopColor * ratio;
       pixels[k*4] = static_cast<unsigned char>( 255.f * Clamp( currentColor.r, 0.f, 1.f ) );
       pixels[k*4+1] = static_cast<unsigned char>( 255.f * Clamp( currentColor.g, 0.f, 1.f ) );
index 0dec934..5d35517 100644 (file)
@@ -120,6 +120,57 @@ const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
     }\n
 );
 
+const char* VERTEX_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
+  attribute mediump vec2 aPosition;\n
+  uniform highp   mat4 uMvpMatrix;\n
+  uniform mediump vec3 uSize;\n
+  uniform mediump vec4 pixelArea;
+  varying mediump vec2 vTexCoord;\n
+  varying mediump vec2 vPosition;\n
+  varying mediump vec2 vRectSize;\n
+  \n
+  //Visual size and offset
+  uniform mediump vec2 offset;\n
+  uniform mediump vec2 size;\n
+  uniform mediump vec4 offsetSizeMode;\n
+  uniform mediump vec2 origin;\n
+  uniform mediump vec2 anchorPoint;\n
+  uniform mediump float cornerRadius;\n
+  \n
+  vec4 ComputeVertexPosition()\n
+  {\n
+    vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
+    vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
+    vRectSize = visualSize / 2.0 - cornerRadius;\n
+    vPosition = aPosition* visualSize;\n
+    return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
+  }\n
+\n
+  void main()\n
+  {\n
+    gl_Position = uMvpMatrix * ComputeVertexPosition();\n
+    vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
+  }\n
+);
+
+//float distance = length( max( abs( position - center ), size ) - size ) - radius;
+const char* FRAGMENT_SHADER_ROUNDED_CORNER = DALI_COMPOSE_SHADER(
+  varying mediump vec2 vTexCoord;\n
+  varying mediump vec2 vPosition;\n
+  varying mediump vec2 vRectSize;\n
+  uniform sampler2D sTexture;\n
+  uniform lowp vec4 uColor;\n
+  uniform lowp vec3 mixColor;\n
+  uniform mediump float cornerRadius;\n
+  \n
+  void main()\n
+  {\n
+      mediump float dist = length( max( abs( vPosition ), vRectSize ) - vRectSize ) - cornerRadius;\n
+      gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
+      gl_FragColor.a *= smoothstep( 1.0, -1.0, dist );\n
+  }\n
+);
+
 } // unnamed namespace
 
 ImageVisualShaderFactory::ImageVisualShaderFactory()
@@ -130,7 +181,7 @@ ImageVisualShaderFactory::~ImageVisualShaderFactory()
 {
 }
 
-Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
+Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner )
 {
   Shader shader;
   if( atlasing )
@@ -158,12 +209,25 @@ Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bo
   }
   else
   {
-    shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
-    if( !shader )
+    if( roundedCorner )
+    {
+      shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER );
+      if( !shader )
+      {
+        shader = Shader::New( VERTEX_SHADER_ROUNDED_CORNER, FRAGMENT_SHADER_ROUNDED_CORNER );
+        shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+        factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ROUNDED_CORNER, shader );
+      }
+    }
+    else
     {
-      shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
-      shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
-      factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
+      shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
+      if( !shader )
+      {
+        shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
+        shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+        factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
+      }
     }
   }
 
index 58b4dd0..c5344d3 100644 (file)
@@ -55,8 +55,9 @@ public:
    * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
    * @param[in] atlasing Whether texture atlasing is applied.
    * @param[in] defaultTextureWrapping Whether the default texture wrap mode is applied.
+   * @param[in] roundedCorner Whether the rounded corder is applied.
    */
-  Shader GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping );
+  Shader GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner );
 
   /**
    * Request the default vertex shader source.
index ceb3669..e79edd7 100644 (file)
@@ -56,15 +56,6 @@ namespace Internal
 namespace
 {
 
-// property names
-const char * const IMAGE_FITTING_MODE( "fittingMode" );
-const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
-const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
-const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
-const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
-const char * const IMAGE_ATLASING("atlasing");
-const char * const ALPHA_MASK_URL("alphaMaskUrl");
-
 // fitting modes
 DALI_ENUM_TO_STRING_TABLE_BEGIN( FITTING_MODE )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::FittingMode, SHRINK_TO_FIT )
@@ -567,7 +558,8 @@ void ImageVisual::CreateRenderer( TextureSet& textureSet )
 
     shader = mImageVisualShaderFactory.GetShader( mFactoryCache,
                              mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
-                             mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE );
+                             mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE,
+                             IsRoundedCornerRequired() );
   }
   else
   {
@@ -662,11 +654,6 @@ void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage )
   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 }
 
-bool ImageVisual::IsSynchronousResourceLoading() const
-{
-  return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
-}
-
 void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection,
                                TextureManager::ReloadPolicy forceReload )
 {
@@ -687,7 +674,7 @@ void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& t
     : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
 
   textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
-                                         mMaskingData, IsSynchronousResourceLoading(), mTextureId,
+                                         mMaskingData, IsSynchronousLoadingRequired(), mTextureId,
                                          atlasRect, mAtlasRectSize, atlasing, mLoading, mWrapModeU,
                                          mWrapModeV, textureObserver, atlasUploadObserver, atlasManager,
                                          mOrientationCorrection, forceReload, preMultiplyOnLoad);
@@ -828,7 +815,7 @@ void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
   map.Clear();
   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE );
 
-  bool sync = IsSynchronousResourceLoading();
+  bool sync = IsSynchronousLoadingRequired();
   map.Insert( SYNCHRONOUS_LOADING, sync );
   if( mImageUrl.IsValid() )
   {
index dcd76f6..23dee63 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_IMAGE_VISUAL_H
 
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -271,6 +271,14 @@ public:
 private:
 
   /**
+   * @copydoc TextureUploadObserver::LoadComplete
+   *
+   * To avoid rendering garbage pixels, renderer should be added to actor after the resources are ready.
+   * This callback is the place to add the renderer as it would be called once the PixelBuffer loading is finished.
+   */
+  void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied ) override {}
+
+  /**
    * Allocate the mask data when a masking property is defined in the property map
    */
   void AllocateMaskData();
@@ -323,12 +331,6 @@ private:
   void CreateNativeImageRenderer( NativeImage& nativeImage );
 
   /**
-   * @brief Query whether resources requires to be loaded synchronously.
-   * @return Returns true if synchronous resource loading is required, false otherwise.
-   */
-  bool IsSynchronousResourceLoading() const;
-
-  /**
    * Creates the texture set and adds the texture to it
    * @param[out] textureRect The texture area of the texture in the atlas.
    * @param[in] url The URL of the image resource to use.
index 19357f5..7fbb28e 100644 (file)
@@ -82,14 +82,6 @@ enum TextureIndex
   GLOSS_INDEX = 2u
 };
 
-//Property names
-const char * const OBJECT_URL_NAME( "objectUrl" );
-const char * const MATERIAL_URL_NAME( "materialUrl" );
-const char * const TEXTURES_PATH_NAME( "texturesPath" );
-const char * const SHADING_MODE_NAME( "shadingMode" );
-const char * const USE_MIPMAPPING_NAME( "useMipmapping" );
-const char * const USE_SOFT_NORMALS_NAME( "useSoftNormals" );
-const char * const LIGHT_POSITION_NAME( "lightPosition" );
 
 //Shading mode
 DALI_ENUM_TO_STRING_TABLE_BEGIN( SHADING_MODE )
index e89ebcb..6745adf 100644 (file)
@@ -1,5 +1,5 @@
  /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,7 +20,6 @@
 
 // EXTERNAL HEADER
 #include <dali/devel-api/adaptor-framework/image-loading.h>
-#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 #include <dali/devel-api/common/hash.h>
 #include <dali/integration-api/debug.h>
 
@@ -248,6 +247,35 @@ void ParseBorders( Devel::PixelBuffer& pixelBuffer, NPatchLoader::Data* data  )
   }
 }
 
+void SetLoadedNPatchData( NPatchLoader::Data* data, Devel::PixelBuffer& pixelBuffer )
+{
+  if( data->border == Rect< int >( 0, 0, 0, 0 ) )
+  {
+    NPatchBuffer::ParseBorders( pixelBuffer, data );
+
+    // Crop the image
+    pixelBuffer.Crop( 1, 1, pixelBuffer.GetWidth() - 2, pixelBuffer.GetHeight() - 2 );
+  }
+  else
+  {
+    data->stretchPixelsX.PushBack( Uint16Pair( data->border.left, ( (pixelBuffer.GetWidth() >= static_cast< unsigned int >( data->border.right )) ? pixelBuffer.GetWidth() - data->border.right : 0 ) ) );
+    data->stretchPixelsY.PushBack( Uint16Pair( data->border.top, ( (pixelBuffer.GetHeight() >= static_cast< unsigned int >( data->border.bottom )) ? pixelBuffer.GetHeight() - data->border.bottom : 0 ) ) );
+  }
+
+  data->croppedWidth = pixelBuffer.GetWidth();
+  data->croppedHeight = pixelBuffer.GetHeight();
+
+  PixelData pixels = Devel::PixelBuffer::Convert( pixelBuffer ); // takes ownership of buffer
+
+  Texture texture = Texture::New( TextureType::TEXTURE_2D, pixels.GetPixelFormat(), pixels.GetWidth(), pixels.GetHeight() );
+  texture.Upload( pixels );
+
+  data->textureSet = TextureSet::New();
+  data->textureSet.SetTexture( 0u, texture );
+
+  data->loadCompleted = true;
+}
+
 } // namespace NPatchBuffer
 
 NPatchLoader::NPatchLoader()
@@ -258,12 +286,13 @@ NPatchLoader::~NPatchLoader()
 {
 }
 
-std::size_t NPatchLoader::Load( const std::string& url, const Rect< int >& border, bool& preMultiplyOnLoad )
+std::size_t NPatchLoader::Load( TextureManager& textureManager, TextureUploadObserver* textureObserver, const std::string& url, const Rect< int >& border, bool& preMultiplyOnLoad, bool synchronousLoading )
 {
   std::size_t hash = CalculateHash( url );
   OwnerContainer< Data* >::SizeType index = UNINITIALIZED_ID;
   const OwnerContainer< Data* >::SizeType count = mCache.Count();
   int cachedIndex = -1;
+  Data* data;
 
   for( ; index < count; ++index )
   {
@@ -275,92 +304,85 @@ std::size_t NPatchLoader::Load( const std::string& url, const Rect< int >& borde
         // Use cached data
         if( mCache[ index ]->border == border )
         {
-          return index+1u; // valid indices are from 1 onwards
+          if( mCache[ index ]->loadCompleted )
+          {
+            return index + 1u; // valid indices are from 1 onwards
+          }
+          data = mCache[ index ];
+          cachedIndex = index + 1u; // valid indices are from 1 onwards
+          break;
         }
         else
         {
-          cachedIndex = index;
-        }
-      }
-    }
-  }
+          if( mCache[ index ]->loadCompleted )
+          {
+            // Same url but border is different - use the existing texture
+            Data* data = new Data();
+            data->hash = hash;
+            data->url = url;
+            data->croppedWidth = mCache[ index ]->croppedWidth;
+            data->croppedHeight = mCache[ index ]->croppedHeight;
 
-  if( cachedIndex != -1 )
-  {
-    // Same url but border is different - use the existing texture
-    Data* data = new Data();
-    data->hash = hash;
-    data->url = url;
-    data->croppedWidth = mCache[ cachedIndex ]->croppedWidth;
-    data->croppedHeight = mCache[ cachedIndex ]->croppedHeight;
+            data->textureSet = mCache[ index ]->textureSet;
 
-    data->textureSet = mCache[ cachedIndex ]->textureSet;
+            StretchRanges stretchRangesX;
+            stretchRangesX.PushBack( Uint16Pair( border.left, ( (data->croppedWidth >= static_cast< unsigned int >( border.right )) ? data->croppedWidth - border.right : 0 ) ) );
 
-    StretchRanges stretchRangesX;
-    stretchRangesX.PushBack( Uint16Pair( border.left, ( (data->croppedWidth >= static_cast< unsigned int >( border.right )) ? data->croppedWidth - border.right : 0 ) ) );
+            StretchRanges stretchRangesY;
+            stretchRangesY.PushBack( Uint16Pair( border.top, ( (data->croppedHeight >= static_cast< unsigned int >( border.bottom )) ? data->croppedHeight - border.bottom : 0 ) ) );
 
-    StretchRanges stretchRangesY;
-    stretchRangesY.PushBack( Uint16Pair( border.top, ( (data->croppedHeight >= static_cast< unsigned int >( border.bottom )) ? data->croppedHeight - border.bottom : 0 ) ) );
+            data->stretchPixelsX = stretchRangesX;
+            data->stretchPixelsY = stretchRangesY;
+            data->border = border;
 
-    data->stretchPixelsX = stretchRangesX;
-    data->stretchPixelsY = stretchRangesY;
-    data->border = border;
+            data->loadCompleted = mCache[ index ]->loadCompleted;
 
-    mCache.PushBack( data );
+            mCache.PushBack( data );
 
-    return mCache.Count(); // valid ids start from 1u
+            return mCache.Count(); // valid ids start from 1u
+          }
+        }
+      }
+    }
   }
 
-  // got to the end so no match, decode N patch and append new item to cache
-  Devel::PixelBuffer pixelBuffer = Dali::LoadImageFromFile( url, ImageDimensions(), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true );
-  if( pixelBuffer )
+  if( cachedIndex == -1 )
   {
-    Data* data = new Data();
+    data = new Data();
+    data->loadCompleted = false;
     data->hash = hash;
     data->url = url;
+    data->border = border;
 
-    if( border == Rect< int >( 0, 0, 0, 0 ) )
-    {
-      NPatchBuffer::ParseBorders( pixelBuffer, data );
-
-      data->border = Rect< int >( 0, 0, 0, 0 );
-
-      // Crop the image
-      pixelBuffer.Crop( 1, 1, pixelBuffer.GetWidth() - 2, pixelBuffer.GetHeight() - 2 );
-    }
-    else
-    {
-      data->stretchPixelsX.PushBack( Uint16Pair( border.left, ( (pixelBuffer.GetWidth() >= static_cast< unsigned int >( border.right )) ? pixelBuffer.GetWidth() - border.right : 0 ) ) );
-      data->stretchPixelsY.PushBack( Uint16Pair( border.top, ( (pixelBuffer.GetHeight() >= static_cast< unsigned int >( border.bottom )) ? pixelBuffer.GetHeight() - border.bottom : 0 ) ) );
-      data->border = border;
-    }
-
-    data->croppedWidth = pixelBuffer.GetWidth();
-    data->croppedHeight = pixelBuffer.GetHeight();
+    mCache.PushBack( data );
 
-    if( preMultiplyOnLoad && Pixel::HasAlpha( pixelBuffer.GetPixelFormat() ) )
-    {
-      pixelBuffer.MultiplyColorByAlpha();
-    }
-    else
-    {
-      preMultiplyOnLoad = false;
-    }
+    cachedIndex = mCache.Count();
+  }
 
-    PixelData pixels = Devel::PixelBuffer::Convert( pixelBuffer ); // takes ownership of buffer
+  auto preMultiplyOnLoading = preMultiplyOnLoad ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
+                                                : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+  Devel::PixelBuffer pixelBuffer = textureManager.LoadPixelBuffer( url, Dali::ImageDimensions(), FittingMode::DEFAULT,
+                                                                   SamplingMode::BOX_THEN_LINEAR, synchronousLoading,
+                                                                   textureObserver, true, preMultiplyOnLoading );
 
-    Texture texture = Texture::New( TextureType::TEXTURE_2D, pixels.GetPixelFormat(), pixels.GetWidth(), pixels.GetHeight() );
-    texture.Upload( pixels );
+  if( pixelBuffer )
+  {
+    NPatchBuffer::SetLoadedNPatchData( data, pixelBuffer );
+    preMultiplyOnLoad = ( preMultiplyOnLoading == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD ) ? true : false;
+  }
 
-    data->textureSet = TextureSet::New();
-    data->textureSet.SetTexture( 0u, texture );
+  return cachedIndex;
+}
 
-    mCache.PushBack( data );
+void NPatchLoader::SetNPatchData( std::size_t id, Devel::PixelBuffer& pixelBuffer )
+{
+  Data* data;
+  data = mCache[ id - 1u ];
 
-    return mCache.Count(); // valid ids start from 1u
+  if( !data->loadCompleted )
+  {
+    NPatchBuffer::SetLoadedNPatchData( data, pixelBuffer );
   }
-
-  return 0u;
 }
 
 bool NPatchLoader::GetNPatchData( std::size_t id, const Data*& data )
index 8c75477..0d39d0d 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_NPATCH_LOADER_H
 
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
 #include <dali/public-api/rendering/texture-set.h>
 #include <dali/public-api/math/uint-16-pair.h>
 #include <dali/devel-api/common/owner-container.h>
+#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+
+// INTERNAL HEADERS
+#include <dali-toolkit/internal/visuals/texture-manager-impl.h>
 
 namespace Dali
 {
@@ -61,6 +65,10 @@ public:
 
   struct Data
   {
+    Data()
+    : loadCompleted( false )
+    {}
+
     std::string url;                              ///< Url of the N-Patch
     TextureSet textureSet;                        ///< Texture containing the cropped image
     StretchRanges stretchPixelsX;                 ///< X stretch pixels
@@ -69,6 +77,7 @@ public:
     uint32_t croppedWidth;                        ///< Width of the cropped middle part of N-patch
     uint32_t croppedHeight;                       ///< Height of the cropped middle part of N-patch
     Rect< int > border;                           ///< The size of the border
+    bool loadCompleted;                           ///< True if the data loading is completed
   };
 
 public:
@@ -86,13 +95,24 @@ public:
   /**
    * @brief Retrieve a texture matching the n-patch url.
    *
+   * @param [in] textureManager that will be used to loading image
+   * @param [in] textureObserver The NPatchVisual that requested loading.
    * @param [in] url to retrieve
    * @param [in] border The border size of the image
    * @param [in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
    *                                   image has no alpha channel
+   * @param [in] synchronousLoading True if the image will be loaded in synchronous time.
    * @return id of the texture.
    */
-  std::size_t Load( const std::string& url, const Rect< int >& border, bool& preMultiplyOnLoad );
+  std::size_t Load( TextureManager& textureManager, TextureUploadObserver* textureObserver, const std::string& url, const Rect< int >& border, bool& preMultiplyOnLoad, bool synchronousLoading );
+
+  /**
+   * @brief Set loaded PixelBuffer and its information
+   *
+   * @param [in] id cache data id
+   * @param [in] pixelBuffer of loaded image
+   */
+  void SetNPatchData( std::size_t id, Devel::PixelBuffer& pixelBuffer );
 
   /**
    * @brief Retrieve N patch data matching to an id
index 85fc08c..4780153 100755 (executable)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -48,11 +48,6 @@ namespace Internal
 
 namespace
 {
-const char * const BORDER_ONLY( "borderOnly" );
-const char * const BORDER( "border" );
-const char * const AUXILIARY_IMAGE_NAME( "auxiliaryImage" );
-const char * const AUXILIARY_IMAGE_ALPHA_NAME( "auxiliaryImageAlpha" );
-
 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
   attribute mediump vec2 aPosition;\n
   varying mediump vec2 vTexCoord;\n
@@ -288,20 +283,28 @@ NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, NinePatchIm
 
 void NPatchVisual::LoadImages()
 {
+  TextureManager& textureManager = mFactoryCache.GetTextureManager();
+  bool synchronousLoading = mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+
   if( NPatchLoader::UNINITIALIZED_ID == mId && mImageUrl.IsLocalResource() )
   {
     bool preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader ? true : false;
+    mId = mLoader.Load( textureManager, this, mImageUrl.GetUrl(), mBorder, preMultiplyOnLoad, synchronousLoading );
 
-    mId = mLoader.Load( mImageUrl.GetUrl(), mBorder, preMultiplyOnLoad );
-
-    EnablePreMultipliedAlpha( preMultiplyOnLoad );
+    const NPatchLoader::Data* data;
+    if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
+    {
+      EnablePreMultipliedAlpha( preMultiplyOnLoad );
+    }
   }
 
-  if( ! mAuxiliaryPixelBuffer && mAuxiliaryUrl.IsValid() && mAuxiliaryUrl.IsLocalResource() )
+  if( !mAuxiliaryPixelBuffer && mAuxiliaryUrl.IsValid() && mAuxiliaryUrl.IsLocalResource() )
   {
-    // Load the auxiliary image synchronously
-    mAuxiliaryPixelBuffer = Dali::LoadImageFromFile( mAuxiliaryUrl.GetUrl(), ImageDimensions(),
-                                                     FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, true );
+    // Load the auxiliary image
+    auto preMultiplyOnLoading = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+    mAuxiliaryPixelBuffer = textureManager.LoadPixelBuffer( mAuxiliaryUrl, Dali::ImageDimensions(), FittingMode::DEFAULT,
+                                                            SamplingMode::BOX_THEN_LINEAR, synchronousLoading,
+                                                            this, true, preMultiplyOnLoading );
   }
 }
 
@@ -311,14 +314,24 @@ void NPatchVisual::GetNaturalSize( Vector2& naturalSize )
   naturalSize.y = 0u;
 
   // load now if not already loaded
-  LoadImages();
-
   const NPatchLoader::Data* data;
-  if( mLoader.GetNPatchData( mId, data ) )
+  if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
   {
     naturalSize.x = data->croppedWidth;
     naturalSize.y = data->croppedHeight;
   }
+  else
+  {
+    if( mImageUrl.IsValid() )
+    {
+      ImageDimensions dimensions = Dali::GetOriginalImageSize( mImageUrl.GetUrl() );
+      if( dimensions != ImageDimensions( 0, 0 ) )
+      {
+        naturalSize.x = dimensions.GetWidth();
+        naturalSize.y = dimensions.GetHeight();
+      }
+    }
+  }
 
   if( mAuxiliaryPixelBuffer )
   {
@@ -366,6 +379,21 @@ void NPatchVisual::DoSetProperties( const Property::Map& propertyMap )
   {
     auxImageAlpha->Get( mAuxiliaryImageAlpha );
   }
+
+  Property::Value* synchronousLoading = propertyMap.Find( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, SYNCHRONOUS_LOADING );
+  if( synchronousLoading )
+  {
+    bool sync = false;
+    synchronousLoading->Get( sync );
+    if( sync )
+    {
+      mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+    }
+    else
+    {
+      mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+    }
+  }
 }
 
 void NPatchVisual::DoSetOnStage( Actor& actor )
@@ -373,22 +401,32 @@ void NPatchVisual::DoSetOnStage( Actor& actor )
   // load when first go on stage
   LoadImages();
 
-  Geometry geometry = CreateGeometry();
-  Shader shader = CreateShader();
-  mImpl->mRenderer = Renderer::New( geometry, shader );
+  const NPatchLoader::Data* data;
+  if( mLoader.GetNPatchData( mId, data ) )
+  {
+    Geometry geometry = CreateGeometry();
+    Shader shader = CreateShader();
 
-  ApplyTextureAndUniforms();
+    mImpl->mRenderer = Renderer::New( geometry, shader );
 
-  actor.AddRenderer( mImpl->mRenderer );
+    mPlacementActor = actor;
+    if( data->loadCompleted )
+    {
+      ApplyTextureAndUniforms();
+      actor.AddRenderer( mImpl->mRenderer );
+      mPlacementActor.Reset();
 
-  // npatch loaded and ready to display
-  ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+      // npatch loaded and ready to display
+      ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+    }
+  }
 }
 
 void NPatchVisual::DoSetOffStage( Actor& actor )
 {
   actor.RemoveRenderer( mImpl->mRenderer );
   mImpl->mRenderer.Reset();
+  mPlacementActor.Reset();
 }
 
 void NPatchVisual::OnSetTransform()
@@ -425,6 +463,7 @@ void NPatchVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 
 NPatchVisual::NPatchVisual( VisualFactoryCache& factoryCache )
 : Visual::Base( factoryCache, Visual::FittingMode::FILL ),
+  mPlacementActor(),
   mLoader( factoryCache.GetNPatchLoader() ),
   mImageUrl(),
   mAuxiliaryUrl(),
@@ -444,7 +483,7 @@ Geometry NPatchVisual::CreateGeometry()
 {
   Geometry geometry;
   const NPatchLoader::Data* data;
-  if( mLoader.GetNPatchData( mId, data ) )
+  if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
   {
     if( data->stretchPixelsX.Size() == 1 && data->stretchPixelsY.Size() == 1 )
     {
@@ -556,7 +595,7 @@ void NPatchVisual::ApplyTextureAndUniforms()
   const NPatchLoader::Data* data;
   TextureSet textureSet;
 
-  if( mLoader.GetNPatchData( mId, data ) )
+  if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
   {
     textureSet = data->textureSet;
 
@@ -773,6 +812,56 @@ Geometry NPatchVisual::CreateBorderGeometry( Uint16Pair gridSize )
   return GenerateGeometry( vertices, indices );
 }
 
+void NPatchVisual::SetResource()
+{
+  const NPatchLoader::Data* data;
+  if( mLoader.GetNPatchData( mId, data ) )
+  {
+    Geometry geometry = CreateGeometry();
+    Shader shader = CreateShader();
+
+    mImpl->mRenderer.SetGeometry( geometry );
+    mImpl->mRenderer.SetShader( shader );
+
+    Actor actor = mPlacementActor.GetHandle();
+    if( actor )
+    {
+      ApplyTextureAndUniforms();
+      actor.AddRenderer( mImpl->mRenderer );
+      mPlacementActor.Reset();
+
+      // npatch loaded and ready to display
+      ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+    }
+  }
+}
+
+void NPatchVisual::LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied )
+{
+  if( url.GetUrl() == mAuxiliaryUrl.GetUrl() )
+  {
+    mAuxiliaryPixelBuffer = pixelBuffer;
+    const NPatchLoader::Data* data;
+    if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
+    {
+      SetResource();
+    }
+  }
+  else
+  {
+    if( loadSuccess )
+    {
+      mLoader.SetNPatchData( mId, pixelBuffer );
+      EnablePreMultipliedAlpha( preMultiplied );
+    }
+
+    if( mAuxiliaryPixelBuffer || !mAuxiliaryUrl.IsValid() )
+    {
+      SetResource();
+    }
+  }
+}
+
 } // namespace Internal
 
 } // namespace Toolkit
index a761628..7816e84 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_N_PATCH_VISUAL_H
 
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
 #include <dali/public-api/rendering/geometry.h>
 #include <dali/public-api/rendering/sampler.h>
 #include <dali/public-api/rendering/shader.h>
+#include <dali/public-api/object/weak-handle.h>
 
 // INTERNAL INCLUDES
+#include <dali-toolkit/internal/visuals/texture-upload-observer.h>
 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
 #include <dali-toolkit/internal/visuals/visual-url.h>
 
@@ -56,7 +58,7 @@ typedef IntrusivePtr< NPatchVisual > NPatchVisualPtr;
  * | auxiliaryImage           | STRING           |
  * | auxiliaryImageAlpha      | FLOAT            |
  */
-class NPatchVisual: public Visual::Base
+class NPatchVisual: public Visual::Base, public TextureUploadObserver
 {
 public:
 
@@ -206,8 +208,32 @@ private:
    */
   Geometry CreateBorderGeometry( Uint16Pair gridSize );
 
+  /**
+   * @brief Creates a renderer by using loaded resource.
+   */
+  void SetResource();
+
+private:
+
+  /**
+   * @copydoc TextureUploadObserver::UploadCompleted
+   *
+   * To avoid rendering garbage pixels, renderer should be added to actor after the resources are ready.
+   * This callback is the place to add the renderer as it would be called once the loading is finished.
+   */
+  void UploadComplete( bool loadSuccess, int32_t textureId, TextureSet textureSet, bool useAtlasing, const Vector4& atlasRect, bool preMultiplied ) override {}
+
+  /**
+   * @copydoc TextureUploadObserver::LoadComplete
+   *
+   * To avoid rendering garbage pixels, renderer should be added to actor after the resources are ready.
+   * This callback is the place to add the renderer as it would be called once the loading is finished.
+   */
+  void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied ) override;
+
 private:
 
+  WeakHandle<Actor>  mPlacementActor;       ///< Weakhandle to contain Actor during texture loading
   NPatchLoader&      mLoader;               ///< reference to N patch loader for fast access
   VisualUrl          mImageUrl;             ///< The url to the N patch to load
   VisualUrl          mAuxiliaryUrl;         ///< An auxiliary image that can be displayed on top of the N-Patch
index 103529b..8b2346c 100644 (file)
@@ -55,19 +55,6 @@ DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::PrimitiveVisual::Shape, BEVELLED_CUBE )
 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::PrimitiveVisual::Shape, CONICAL_FRUSTUM )
 DALI_ENUM_TO_STRING_TABLE_END( SHAPE_TYPE )
 
-//Property names
-const char * const PRIMITIVE_SHAPE( "shape" );
-const char * const SLICES( "slices" );
-const char * const STACKS( "stacks" );
-const char * const SCALE_TOP_RADIUS( "scaleTopRadius" );
-const char * const SCALE_BOTTOM_RADIUS( "scaleBottomRadius" );
-const char * const SCALE_HEIGHT( "scaleHeight" );
-const char * const SCALE_RADIUS( "scaleRadius" );
-const char * const SCALE_DIMENSIONS( "scaleDimensions" );
-const char * const BEVEL_PERCENTAGE( "bevelPercentage" );
-const char * const BEVEL_SMOOTHNESS( "bevelSmoothness" );
-const char * const LIGHT_POSITION_UNIFORM_NAME( "lightPosition" );
-
 //Primitive property defaults
 const int     DEFAULT_SLICES =              128; ///< For spheres and conics
 const int     DEFAULT_STACKS =              128; ///< For spheres and conics
index 174183e..f0dc4a4 100644 (file)
@@ -49,6 +49,12 @@ RasterizingTask::RasterizingTask( SvgVisual* svgRenderer, NSVGimage* parsedSvg,
   mWidth( width ),
   mHeight( height )
 {
+  mRasterizer = nsvgCreateRasterizer();
+}
+
+RasterizingTask::~RasterizingTask()
+{
+  nsvgDeleteRasterizer( mRasterizer );
 }
 
 void RasterizingTask::Load()
@@ -73,7 +79,7 @@ void RasterizingTask::Load()
   }
 }
 
-void RasterizingTask::Rasterize( NSVGrasterizer* rasterizer )
+void RasterizingTask::Rasterize( )
 {
   if( mParsedSvg != NULL && mWidth > 0u && mHeight > 0u )
   {
@@ -84,7 +90,7 @@ void RasterizingTask::Rasterize( NSVGrasterizer* rasterizer )
     unsigned int bufferSize = bufferStride * mHeight;
 
     unsigned char* buffer = new unsigned char [bufferSize];
-    nsvgRasterize(rasterizer, mParsedSvg, 0.f,0.f,scale,
+    nsvgRasterize(mRasterizer, mParsedSvg, 0.f,0.f,scale,
         buffer, mWidth, mHeight,
         bufferStride );
 
@@ -111,13 +117,10 @@ SvgRasterizeThread::SvgRasterizeThread( EventThreadCallback* trigger )
 : mTrigger( trigger ),
   mIsThreadWaiting( false )
 {
-  mRasterizer = nsvgCreateRasterizer();
 }
 
 SvgRasterizeThread::~SvgRasterizeThread()
 {
-
-  nsvgDeleteRasterizer( mRasterizer );
   delete mTrigger;
 }
 
@@ -264,7 +267,7 @@ void SvgRasterizeThread::Run()
   while( RasterizingTaskPtr task = NextTaskToProcess() )
   {
     task->Load( );
-    task->Rasterize( mRasterizer );
+    task->Rasterize( );
     AddCompletedTask( task );
   }
 }
index 1c94ca9..b7bdbfd 100644 (file)
@@ -73,10 +73,14 @@ public:
   RasterizingTask( SvgVisual* svgRenderer, NSVGimage* parsedSvg, const VisualUrl& url, float dpi, unsigned int width, unsigned int height );
 
   /**
-   * Do the rasterization with the given rasterizer.
-   *@param[in] rasterizer The rasterizer that rasterize the SVG to a buffer image
+   * Destructor.
+   */
+  ~RasterizingTask();
+
+  /**
+   * Do the rasterization with the mRasterizer.
    */
-  void Rasterize( NSVGrasterizer* rasterizer );
+  void Rasterize( );
 
   /**
    * Get the svg visual
@@ -115,6 +119,7 @@ private:
   float           mDpi;
   unsigned int    mWidth;
   unsigned int    mHeight;
+  NSVGrasterizer* mRasterizer;
 };
 
 /**
@@ -216,7 +221,6 @@ private:
   Dali::Mutex                mMutex;
   EventThreadCallback*       mTrigger;
 
-  NSVGrasterizer*            mRasterizer;
   bool                       mIsThreadWaiting;
 };
 
index 45566bc..9330bdb 100644 (file)
@@ -20,6 +20,7 @@
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/third-party/nanosvg/nanosvg.h>
+#include <dali-toolkit/third-party/nanosvg/nanosvgrast.h>
 #include <dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h>
 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
@@ -29,6 +30,7 @@
 
 // EXTERNAL INCLUDES
 #include <dali/public-api/common/stage.h>
+#include <dali/integration-api/debug.h>
 
 namespace Dali
 {
@@ -44,9 +46,8 @@ namespace
 // property name
 const char * const UNITS("px");
 
-const char * const IMAGE_ATLASING( "atlasing" );
-
 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+
 }
 
 SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
@@ -102,6 +103,10 @@ void SvgVisual::DoSetProperties( const Property::Map& propertyMap )
     {
       DoSetProperty( Toolkit::ImageVisual::Property::ATLASING, keyValue.second );
     }
+    else if( keyValue.first == SYNCHRONOUS_LOADING )
+    {
+      DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
+    }
   }
 }
 
@@ -114,6 +119,26 @@ void SvgVisual::DoSetProperty( Property::Index index, const Property::Value& val
       value.Get( mAttemptAtlasing );
       break;
     }
+    case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
+    {
+      bool sync = false;
+      if( value.Get( sync ) )
+      {
+        if( sync )
+        {
+          mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+        }
+        else
+        {
+          mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+        }
+      }
+      else
+      {
+        DALI_LOG_ERROR("ImageVisual: synchronousLoading property has incorrect type\n");
+      }
+      break;
+    }
   }
 }
 
@@ -122,7 +147,7 @@ void SvgVisual::DoSetOnStage( Actor& actor )
   Shader shader;
   if( !mImpl->mCustomShader )
   {
-    shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true );
+    shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true, false );
   }
   else
   {
@@ -218,7 +243,15 @@ void SvgVisual::AddRasterizationTask( const Vector2& size )
     float meanDpi = ( dpi.height + dpi.width ) * 0.5f;
 
     RasterizingTaskPtr newTask = new RasterizingTask( this, mParsedImage, mImageUrl, meanDpi, width, height );
-    mFactoryCache.GetSVGRasterizationThread()->AddTask( newTask );
+    if ( IsSynchronousLoadingRequired() )
+    {
+      newTask->Rasterize();
+      ApplyRasterizedImage( newTask->GetParsedImage(), newTask->GetPixelData() );
+    }
+    else
+    {
+      mFactoryCache.GetSVGRasterizationThread()->AddTask( newTask );
+    }
   }
 }
 
index 1171033..e0b16e9 100755 (executable)
@@ -49,21 +49,6 @@ namespace Internal
 
 namespace
 {
-
-// Property names - common properties defined in visual-string-constants.h/cpp
-const char * const FONT_FAMILY_PROPERTY( "fontFamily" );
-const char * const FONT_STYLE_PROPERTY( "fontStyle" );
-const char * const POINT_SIZE_PROPERTY( "pointSize" );
-const char * const MULTI_LINE_PROPERTY( "multiLine" );
-const char * const HORIZONTAL_ALIGNMENT_PROPERTY( "horizontalAlignment" );
-const char * const VERTICAL_ALIGNMENT_PROPERTY( "verticalAlignment" );
-const char * const TEXT_COLOR_PROPERTY( "textColor" );
-const char * const ENABLE_MARKUP_PROPERTY( "enableMarkup" );
-const char * const SHADOW_PROPERTY( "shadow" );
-const char * const UNDERLINE_PROPERTY( "underline" );
-const char * const OUTLINE_PROPERTY( "outline" );
-const char * const BACKGROUND_PROPERTY( "textBackground" );
-
 const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
 
 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
index bf78d25..b34b9f1 100644 (file)
@@ -144,6 +144,32 @@ TextureManager::~TextureManager()
   }
 }
 
+Devel::PixelBuffer TextureManager::LoadPixelBuffer(
+  const VisualUrl& url, Dali::ImageDimensions desiredSize, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode, bool synchronousLoading, TextureUploadObserver* textureObserver, bool orientationCorrection, TextureManager::MultiplyOnLoad& preMultiplyOnLoad )
+{
+  Devel::PixelBuffer pixelBuffer;
+  if( synchronousLoading )
+  {
+    if( url.IsValid() )
+    {
+      pixelBuffer = LoadImageFromFile( url.GetUrl(), desiredSize, fittingMode, samplingMode,
+                                       orientationCorrection  );
+      if( pixelBuffer && preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD )
+      {
+        PreMultiply( pixelBuffer, preMultiplyOnLoad );
+      }
+    }
+  }
+  else
+  {
+    RequestLoadInternal( url, INVALID_TEXTURE_ID, 1.0f, desiredSize, fittingMode, samplingMode, TextureManager::NO_ATLAS,
+                         false, KEEP_PIXEL_BUFFER, textureObserver, orientationCorrection, TextureManager::ReloadPolicy::FORCED,
+                         preMultiplyOnLoad, true );
+  }
+
+  return pixelBuffer;
+}
+
 TextureSet TextureManager::LoadTexture(
   const VisualUrl& url, Dali::ImageDimensions desiredSize, Dali::FittingMode::Type fittingMode,
   Dali::SamplingMode::Type samplingMode, MaskingDataPointer& maskInfo,
@@ -311,7 +337,7 @@ TextureManager::TextureId TextureManager::RequestLoad(
 {
   return RequestLoadInternal( url, INVALID_TEXTURE_ID, 1.0f, desiredSize, fittingMode, samplingMode, useAtlas,
                               false, UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
-                              preMultiplyOnLoad );
+                              preMultiplyOnLoad, false );
 }
 
 TextureManager::TextureId TextureManager::RequestLoad(
@@ -330,7 +356,7 @@ TextureManager::TextureId TextureManager::RequestLoad(
 {
   return RequestLoadInternal( url, maskTextureId, contentScale, desiredSize, fittingMode, samplingMode, useAtlas,
                               cropToMask, UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
-                              preMultiplyOnLoad );
+                              preMultiplyOnLoad, false );
 }
 
 TextureManager::TextureId TextureManager::RequestMaskLoad( const VisualUrl& maskUrl )
@@ -339,7 +365,7 @@ TextureManager::TextureId TextureManager::RequestMaskLoad( const VisualUrl& mask
   auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
   return RequestLoadInternal( maskUrl, INVALID_TEXTURE_ID, 1.0f, ImageDimensions(), FittingMode::SCALE_TO_FILL,
                               SamplingMode::NO_FILTER, NO_ATLAS, false, KEEP_PIXEL_BUFFER, NULL, true,
-                              TextureManager::ReloadPolicy::CACHED, preMultiply );
+                              TextureManager::ReloadPolicy::CACHED, preMultiply, false );
 }
 
 TextureManager::TextureId TextureManager::RequestLoadInternal(
@@ -355,7 +381,8 @@ TextureManager::TextureId TextureManager::RequestLoadInternal(
   TextureUploadObserver*          observer,
   bool                            orientationCorrection,
   TextureManager::ReloadPolicy    reloadPolicy,
-  TextureManager::MultiplyOnLoad& preMultiplyOnLoad)
+  TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
+  bool                            loadPixelBuffer )
 {
   // First check if the requested Texture is cached.
   const TextureHash textureHash = GenerateHash( url.GetUrl(), desiredSize, fittingMode, samplingMode, useAtlas,
@@ -393,7 +420,7 @@ TextureManager::TextureId TextureManager::RequestLoadInternal(
     mTextureInfoContainer.push_back( TextureInfo( textureId, maskTextureId, url.GetUrl(),
                                                   desiredSize, contentScale, fittingMode, samplingMode,
                                                   false, cropToMask, useAtlas, textureHash, orientationCorrection,
-                                                  preMultiply ) );
+                                                  preMultiply, loadPixelBuffer ) );
     cacheIndex = mTextureInfoContainer.size() - 1u;
 
     DALI_LOG_INFO( gTextureManagerLogFilter, Debug::General, "TextureManager::RequestLoad( url=%s observer=%p ) New texture, cacheIndex:%d, textureId=%d\n",
@@ -459,7 +486,11 @@ TextureManager::TextureId TextureManager::RequestLoadInternal(
       break;
     }
     case TextureManager::LOAD_FINISHED:
-      // Loading has already completed. Do nothing.
+      // Loading has already completed.
+      if( observer && textureInfo.loadPixelBuffer )
+      {
+        LoadOrQueueTexture( textureInfo, observer );
+      }
       break;
   }
 
@@ -755,6 +786,10 @@ void TextureManager::ProcessQueuedTextures()
                                            textureInfo.useAtlas, textureInfo.atlasRect,
                                            textureInfo.preMultiplied );
       }
+      else if ( textureInfo.loadState == LOAD_FINISHED && textureInfo.loadPixelBuffer )
+      {
+        element.mObserver->LoadComplete( true, textureInfo.pixelBuffer, textureInfo.url, textureInfo.preMultiplied );
+      }
       else
       {
         LoadTexture( textureInfo, element.mObserver );
@@ -820,6 +855,7 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
   {
     // No atlas support for now
     textureInfo.useAtlas = NO_ATLAS;
+    textureInfo.preMultiplied = pixelBuffer.IsAlphaPreMultiplied();
 
     if( textureInfo.storageType == UPLOAD_TO_TEXTURE )
     {
@@ -860,6 +896,10 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
       textureInfo.pixelBuffer = pixelBuffer; // Store the pixel data
       textureInfo.loadState = LOAD_FINISHED;
 
+      if( textureInfo.loadPixelBuffer )
+      {
+        NotifyObservers( textureInfo, true );
+      }
       // Check if there was another texture waiting for this load to complete
       // (e.g. if this was an image mask, and its load is on a different thread)
       CheckForWaitingTexture( textureInfo );
@@ -976,8 +1016,16 @@ void TextureManager::NotifyObservers( TextureInfo& textureInfo, bool success )
     DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "NotifyObservers() url:%s loadState:%s\n",
                    textureInfo.url.GetUrl().c_str(), GET_LOAD_STATE_STRING(textureInfo.loadState ) );
 
-    observer->UploadComplete( success, info->textureId, info->textureSet, info->useAtlas, info->atlasRect,
-                              info->preMultiplied );
+    if( info->loadPixelBuffer )
+    {
+      observer->LoadComplete( success, info->pixelBuffer, info->url, info->preMultiplied );
+    }
+    else
+    {
+      observer->UploadComplete( success, info->textureId, info->textureSet, info->useAtlas, info->atlasRect,
+                                info->preMultiplied );
+    }
+
     observer->DestructionSignal().Disconnect( this, &TextureManager::ObserverDestroyed );
 
     // Get the textureInfo from the container again as it may have been invalidated.
@@ -1001,6 +1049,11 @@ void TextureManager::NotifyObservers( TextureInfo& textureInfo, bool success )
 
   mQueueLoadFlag = false;
   ProcessQueuedTextures();
+
+  if( info->loadPixelBuffer && info->observerList.Count() == 0 )
+  {
+    Remove( info->textureId, nullptr );
+  }
 }
 
 TextureManager::TextureId TextureManager::GenerateUniqueTextureId()
index 7d66256..5146991 100755 (executable)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
 
 /*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -163,6 +163,36 @@ public:
   // TextureManager Main API:
 
   /**
+   * @brief Requests an image load of the given URL to get PixelBuffer.
+   *
+   * The parameters are used to specify how the image is loaded.
+   * The observer has the LoadComplete method called when the load is ready.
+   *
+   * @param[in] url                   The URL of the image to load
+   * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
+   * @param[in] fittingMode           The FittingMode to use
+   * @param[in] samplingMode          The SamplingMode to use
+   * @param[in] synchronousLoading    true if the URL should be loaded synchronously
+   * @param[in] textureObserver       The client object should inherit from this and provide the "UploadCompleted" virtual.
+   *                                  This is called when an image load completes (or fails).
+   * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
+   * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
+   *                                  image has no alpha channel
+   *
+   * @return                          The pixel buffer containing the image, or empty if still loading.
+   */
+
+  Devel::PixelBuffer LoadPixelBuffer( const VisualUrl& url,
+                                      Dali::ImageDimensions desiredSize,
+                                      Dali::FittingMode::Type fittingMode,
+                                      Dali::SamplingMode::Type samplingMode,
+                                      bool synchronousLoading,
+                                      TextureUploadObserver* textureObserver,
+                                      bool orientationCorrection,
+                                      TextureManager::MultiplyOnLoad& preMultiplyOnLoad );
+
+
+  /**
    * @brief Requests an image load of the given URL.
    *
    * The parameters are used to specify how the image is loaded.
@@ -415,7 +445,8 @@ private:
     TextureUploadObserver*              observer,
     bool                                orientationCorrection,
     TextureManager::ReloadPolicy        reloadPolicy,
-    MultiplyOnLoad&                     preMultiplyOnLoad );
+    MultiplyOnLoad&                     preMultiplyOnLoad,
+    bool                                loadPixelBuffer );
 
   /**
    * @brief Get the current state of a texture
@@ -446,7 +477,8 @@ private:
                  UseAtlas useAtlas,
                  TextureManager::TextureHash hash,
                  bool orientationCorrection,
-                 bool preMultiplyOnLoad )
+                 bool preMultiplyOnLoad,
+                 bool loadPixelBuffer )
     : url( url ),
       desiredSize( desiredSize ),
       useSize( desiredSize ),
@@ -465,7 +497,8 @@ private:
       cropToMask( cropToMask ),
       orientationCorrection( true ),
       preMultiplyOnLoad( preMultiplyOnLoad ),
-      preMultiplied( false )
+      preMultiplied( false ),
+      loadPixelBuffer( loadPixelBuffer )
     {
     }
 
@@ -498,6 +531,7 @@ private:
     bool orientationCorrection:1;  ///< true if the image should be rotated to match exif orientation data
     bool preMultiplyOnLoad:1;      ///< true if the image's color should be multiplied by it's alpha
     bool preMultiplied:1;          ///< true if the image's color was multiplied by it's alpha
+    bool loadPixelBuffer:1;        ///< true if the image is needed to be returned as PixelBuffer
   };
 
   /**
index 1bf9944..b00722c 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_TEXTURE_UPLOAD_OBSERVER_H
 
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  *
  */
 
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 #include <dali/public-api/signals/dali-signal.h>
 
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/dali-toolkit-common.h>
+#include <dali-toolkit/internal/visuals/visual-url.h>
+
 namespace Dali
 {
 
@@ -67,6 +72,17 @@ public:
                                const Vector4& atlasRect, bool preMultiplied ) = 0;
 
   /**
+   * The action to be taken once the async load has finished.
+   * This should be overridden by the deriving class.
+   *
+   * @param[in] loadSuccess   True if the image load was successful (i.e. the resource is available). If false, then the resource failed to load.
+   * @param[in] pixelBuffer   The PixelBuffer of the loaded image.
+   * @param[in] url           The url address of the loaded image.
+   * @param[in] preMultiplied True if the image had pre-multiplied alpha applied
+   */
+  virtual void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const Internal::VisualUrl& url, bool preMultiplied ) = 0;
+
+  /**
    * @brief Returns the destruction signal.
    * This is emitted when the observer is destroyed.
    * This is used by the observer notifier to mark this observer as destroyed (IE. It no longer needs notifying).
index 3702aa3..67d54d5 100644 (file)
@@ -121,8 +121,10 @@ Internal::Visual::Base::Impl::Impl(FittingMode fittingMode)
   mTransform(),
   mMixColor( Color::WHITE ),
   mControlSize( Vector2::ZERO ),
+  mCornerRadius( 0.0f ),
   mDepthIndex( 0.0f ),
   mMixColorIndex( Property::INVALID_INDEX ),
+  mCornerRadiusIndex( Property::INVALID_INDEX ),
   mFittingMode( fittingMode ),
   mFlags( 0 ),
   mResourceStatus( Toolkit::Visual::ResourceStatus::PREPARING )
index 4adcc5a..123a722 100644 (file)
@@ -124,8 +124,10 @@ struct Base::Impl
   Transform       mTransform;
   Vector4         mMixColor;
   Size            mControlSize;
+  float           mCornerRadius;
   int             mDepthIndex;
   Property::Index mMixColorIndex;
+  Property::Index mCornerRadiusIndex;
   FittingMode     mFittingMode;  //< How the contents should fit the view
   int             mFlags;
   Toolkit::Visual::ResourceStatus  mResourceStatus;
index d14dcd3..b03a5ef 100755 (executable)
@@ -121,6 +121,10 @@ void Visual::Base::SetProperties( const Property::Map& propertyMap )
       {
         matchKey = Property::Key( Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE );
       }
+      else if( matchKey == CORNER_RADIUS )
+      {
+        matchKey = Property::Key( Toolkit::DevelVisual::Property::CORNER_RADIUS );
+      }
     }
 
     switch( matchKey.indexKey )
@@ -188,6 +192,15 @@ void Visual::Base::SetProperties( const Property::Map& propertyMap )
           value, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT, mImpl->mFittingMode );
         break;
       }
+      case Toolkit::DevelVisual::Property::CORNER_RADIUS:
+      {
+        float radius;
+        if( value.Get( radius ) )
+        {
+          mImpl->mCornerRadius = radius;
+        }
+        break;
+      }
     }
   }
 
@@ -279,6 +292,13 @@ void Visual::Base::SetOnStage( Actor& actor )
     {
       RegisterMixColor();
 
+      if( IsRoundedCornerRequired() )
+      {
+        mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty( CORNER_RADIUS, mImpl->mCornerRadius );
+
+        mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+      }
+
       mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, IsPreMultipliedAlphaEnabled());
       mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex );
       mImpl->mFlags |= Impl::IS_ON_STAGE; // Only sets the flag if renderer exists
@@ -292,6 +312,7 @@ void Visual::Base::SetOffStage( Actor& actor )
   {
     DoSetOffStage( actor );
     mImpl->mMixColorIndex = Property::INVALID_INDEX;
+    mImpl->mCornerRadiusIndex = Property::INVALID_INDEX;
     mImpl->mFlags &= ~Impl::IS_ON_STAGE;
   }
 }
@@ -316,10 +337,13 @@ void Visual::Base::CreatePropertyMap( Property::Map& map ) const
   // which is ok, because they have a different key value range.
   map.Insert( Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor ); // vec4
   map.Insert( Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a );
+  map.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired() );
 
   auto fittingModeString = Scripting::GetLinearEnumerationName< FittingMode >(
     mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT );
   map.Insert( Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE, fittingModeString );
+
+  map.Insert( Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius );
 }
 
 void Visual::Base::CreateInstancePropertyMap( Property::Map& map ) const
@@ -370,6 +394,11 @@ bool Visual::Base::IsOnStage() const
   return mImpl->mFlags & Impl::IS_ON_STAGE;
 }
 
+bool Visual::Base::IsRoundedCornerRequired() const
+{
+  return !EqualsZero( mImpl->mCornerRadius );
+}
+
 void Visual::Base::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 {
   // May be overriden by derived class
@@ -464,6 +493,11 @@ bool Visual::Base::IsResourceReady() const
   return ( mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY );
 }
 
+bool Visual::Base::IsSynchronousLoadingRequired() const
+{
+  return ( mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING );
+}
+
 Toolkit::Visual::ResourceStatus Visual::Base::GetResourceStatus() const
 {
   return mImpl->mResourceStatus;
index 754c838..a04fa1f 100644 (file)
@@ -266,6 +266,12 @@ public:
    */
   virtual Base& GetVisualObject();
 
+  /**
+   * @brief Query whether resources requires to be loaded synchronously.
+   * @return Returns true if synchronous resource loading is required, false otherwise.
+   */
+  bool IsSynchronousLoadingRequired() const;
+
  protected:
 
   /**
@@ -344,6 +350,13 @@ protected:
    */
   bool IsOnStage() const;
 
+  /**
+   * @brief Query whether the corners of the visual requires to be rounded.
+   *
+   * @return Returns true if the rounded corner is required, false otherwise.
+   */
+  bool IsRoundedCornerRequired() const;
+
 private:
 
   /**
index e080d52..f01260f 100644 (file)
@@ -58,6 +58,7 @@ public:
   enum ShaderType
   {
     COLOR_SHADER,
+    COLOR_SHADER_ROUNDED_CORNER,
     BORDER_SHADER,
     BORDER_SHADER_ANTI_ALIASING,
     GRADIENT_SHADER_LINEAR_USER_SPACE,
@@ -67,6 +68,7 @@ public:
     IMAGE_SHADER,
     IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
     IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
+    IMAGE_SHADER_ROUNDED_CORNER,
     NINE_PATCH_SHADER,
     NINE_PATCH_MASK_SHADER,
     TEXT_SHADER_MULTI_COLOR_TEXT,
index af16305..79f6163 100644 (file)
@@ -76,6 +76,9 @@ const char * const OPACITY( "opacity" );
 // Fitting mode
 const char * const VISUAL_FITTING_MODE( "visualFittingMode" );
 
+// Corner radius
+const char * const CORNER_RADIUS( "cornerRadius" );
+
 // Color visual
 const char * const RENDER_IF_TRANSPARENT_NAME( "renderIfTransparent" );
 
@@ -106,9 +109,106 @@ const char * const CURRENT_FRAME_NUMBER_NAME( "currentFrameNumber" );
 const char * const TOTAL_FRAME_NUMBER_NAME( "totalFrameNumber" );
 const char * const STOP_BEHAVIOR_NAME( "stopBehavior" );
 const char * const LOOPING_MODE_NAME( "loopingMode" );
+const char * const IMAGE_ATLASING( "atlasing" );
+const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
+const char * const IMAGE_FITTING_MODE( "fittingMode" );
+const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
+const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
+const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
+const char * const ALPHA_MASK_URL("alphaMaskUrl");
 
 // Text visual
 const char * const TEXT_PROPERTY( "text" );
+const char * const FONT_FAMILY_PROPERTY( "fontFamily" );
+const char * const FONT_STYLE_PROPERTY( "fontStyle" );
+const char * const POINT_SIZE_PROPERTY( "pointSize" );
+const char * const MULTI_LINE_PROPERTY( "multiLine" );
+const char * const HORIZONTAL_ALIGNMENT_PROPERTY( "horizontalAlignment" );
+const char * const VERTICAL_ALIGNMENT_PROPERTY( "verticalAlignment" );
+const char * const TEXT_COLOR_PROPERTY( "textColor" );
+const char * const ENABLE_MARKUP_PROPERTY( "enableMarkup" );
+const char * const SHADOW_PROPERTY( "shadow" );
+const char * const UNDERLINE_PROPERTY( "underline" );
+const char * const OUTLINE_PROPERTY( "outline" );
+const char * const BACKGROUND_PROPERTY( "textBackground" );
+
+
+//NPatch visual
+const char * const BORDER_ONLY( "borderOnly" );
+const char * const BORDER( "border" );
+
+// non-animated property
+const char* const GRADIENT_TYPE_NAME("gradientType");
+const char* const UNIT_TYPE_NAME("unitType");
+const char* const SPREAD_TYPE_NAME("spreadType");
+
+// animated property
+const char* const START_POSITION_NAME("startPosition");
+const char* const START_COLOR_NAME("startColor");
+const char* const END_POSITION_NAME("endPosition");
+const char* const END_COLOR_NAME("endColor");
+const char* const ROTATE_CENTER_NAME("rotateCenter");
+const char* const ROTATE_AMOUNT_NAME("rotateAmount");
+const char* const OFFSET_NAME("offset");
+
+// animation parameter property
+const char* const START_VALUE_NAME("startValue");
+const char* const TARGET_VALUE_NAME("targetValue");
+const char* const DIRECTION_TYPE_NAME("directionType");
+const char* const DURATION_NAME("duration");
+const char* const DELAY_NAME("delay");
+const char* const REPEAT_NAME("repeat");
+const char* const REPEAT_DELAY_NAME("repeatDelay");
+const char* const MOTION_TYPE_NAME("motionType");
+const char* const EASING_TYPE_NAME("easingType");
+
+// common shader property
+const char* const UNIFORM_START_POINT_NAME("start_point");
+const char* const UNIFORM_START_COLOR_NAME("start_color");
+const char* const UNIFORM_END_POINT_NAME("end_point");
+const char* const UNIFORM_END_COLOR_NAME("end_color");
+const char* const UNIFORM_ROTATE_CENTER_NAME("rotate_center");
+const char* const UNIFORM_ROTATE_ANGLE_NAME("rotate_angle");
+const char* const UNIFORM_OFFSET_NAME("gradient_offset");
+
+// Border visual
+const char * const COLOR_NAME("borderColor");
+const char * const SIZE_NAME("borderSize");
+const char * const ANTI_ALIASING("antiAliasing");
+
+// properties: radial gradient
+const char * const CENTER_NAME("center"); // Property::VECTOR2
+const char * const RADIUS_NAME("radius"); // Property::FLOAT
+
+// properties: linear&radial gradient
+const char * const STOP_OFFSET_NAME("stopOffset"); // Property::Array FLOAT
+const char * const STOP_COLOR_NAME("stopColor"); // Property::Array VECTOR4
+const char * const UNITS_NAME("units"); // Property::String  "userSpaceOnUse | objectBoundingBox"
+const char * const SPREAD_METHOD_NAME("spreadMethod"); // Property::String  "pad | reflect | repeat"
+
+//mesh visual
+const char * const OBJECT_URL_NAME( "objectUrl" );
+const char * const MATERIAL_URL_NAME( "materialUrl" );
+const char * const TEXTURES_PATH_NAME( "texturesPath" );
+const char * const SHADING_MODE_NAME( "shadingMode" );
+const char * const USE_MIPMAPPING_NAME( "useMipmapping" );
+const char * const USE_SOFT_NORMALS_NAME( "useSoftNormals" );
+const char * const LIGHT_POSITION_NAME( "lightPosition" );
+
+
+//Primitive properties
+const char * const PRIMITIVE_SHAPE( "shape" );
+const char * const SLICES( "slices" );
+const char * const STACKS( "stacks" );
+const char * const SCALE_TOP_RADIUS( "scaleTopRadius" );
+const char * const SCALE_BOTTOM_RADIUS( "scaleBottomRadius" );
+const char * const SCALE_HEIGHT( "scaleHeight" );
+const char * const SCALE_RADIUS( "scaleRadius" );
+const char * const SCALE_DIMENSIONS( "scaleDimensions" );
+const char * const BEVEL_PERCENTAGE( "bevelPercentage" );
+const char * const BEVEL_SMOOTHNESS( "bevelSmoothness" );
+const char * const LIGHT_POSITION_UNIFORM_NAME( "lightPosition" );
+
 
 } // namespace Internal
 
index fff497f..8415819 100644 (file)
@@ -61,6 +61,9 @@ extern const char * const OPACITY;
 // Fitting mode
 extern const char * const VISUAL_FITTING_MODE;
 
+// Corner radius
+extern const char * const CORNER_RADIUS;
+
 // Color visual
 extern const char * const RENDER_IF_TRANSPARENT_NAME;
 
@@ -91,9 +94,105 @@ extern const char * const CURRENT_FRAME_NUMBER_NAME;
 extern const char * const TOTAL_FRAME_NUMBER_NAME;
 extern const char * const STOP_BEHAVIOR_NAME;
 extern const char * const LOOPING_MODE_NAME;
+extern const char * const IMAGE_ATLASING;
+extern const char * const SYNCHRONOUS_LOADING;
+extern const char * const IMAGE_FITTING_MODE;
+extern const char * const IMAGE_SAMPLING_MODE;
+extern const char * const IMAGE_DESIRED_WIDTH;
+extern const char * const IMAGE_DESIRED_HEIGHT;
+extern const char * const ALPHA_MASK_URL;
 
 // Text visual
 extern const char * const TEXT_PROPERTY;
+extern const char * const FONT_FAMILY_PROPERTY;
+extern const char * const FONT_STYLE_PROPERTY;
+extern const char * const POINT_SIZE_PROPERTY;
+extern const char * const MULTI_LINE_PROPERTY;
+extern const char * const HORIZONTAL_ALIGNMENT_PROPERTY;
+extern const char * const VERTICAL_ALIGNMENT_PROPERTY;
+extern const char * const TEXT_COLOR_PROPERTY;
+extern const char * const ENABLE_MARKUP_PROPERTY;
+extern const char * const SHADOW_PROPERTY;
+extern const char * const UNDERLINE_PROPERTY;
+extern const char * const OUTLINE_PROPERTY;
+extern const char * const BACKGROUND_PROPERTY;
+
+//NPatch visual
+extern const char * const BORDER_ONLY;
+extern const char * const BORDER;
+extern const char * const AUXILIARY_IMAGE_NAME;
+extern const char * const AUXILIARY_IMAGE_ALPHA_NAME;
+
+// non-animated property
+extern const char* const GRADIENT_TYPE_NAME;
+extern const char* const UNIT_TYPE_NAME;
+extern const char* const SPREAD_TYPE_NAME;
+
+// animated property
+extern const char* const START_POSITION_NAME;
+extern const char* const START_COLOR_NAME;
+extern const char* const END_POSITION_NAME;
+extern const char* const END_COLOR_NAME;
+extern const char* const ROTATE_CENTER_NAME;
+extern const char* const ROTATE_AMOUNT_NAME;
+extern const char* const OFFSET_NAME;
+
+// animation parameter property
+extern const char* const START_VALUE_NAME;
+extern const char* const TARGET_VALUE_NAME;
+extern const char* const DIRECTION_TYPE_NAME;
+extern const char* const DURATION_NAME;
+extern const char* const DELAY_NAME;
+extern const char* const REPEAT_NAME;
+extern const char* const REPEAT_DELAY_NAME;
+extern const char* const MOTION_TYPE_NAME;
+extern const char* const EASING_TYPE_NAME;
+
+// common shader property
+extern const char* const UNIFORM_START_POINT_NAME;
+extern const char* const UNIFORM_START_COLOR_NAME;
+extern const char* const UNIFORM_END_POINT_NAME;
+extern const char* const UNIFORM_END_COLOR_NAME;
+extern const char* const UNIFORM_ROTATE_CENTER_NAME;
+extern const char* const UNIFORM_ROTATE_ANGLE_NAME;
+extern const char* const UNIFORM_OFFSET_NAME;
+
+// Border visual
+extern const char * const COLOR_NAME;
+extern const char * const SIZE_NAME;
+extern const char * const ANTI_ALIASING;
+
+// properties: radial gradient
+extern const char * const CENTER_NAME; // Property::VECTOR2
+extern const char * const RADIUS_NAME; // Property::FLOAT
+
+// properties: linear&radial gradient
+extern const char * const STOP_OFFSET_NAME; // Property::Array FLOAT
+extern const char * const STOP_COLOR_NAME; // Property::Array VECTOR4
+extern const char * const UNITS_NAME; // Property::String  "userSpaceOnUse | objectBoundingBox"
+extern const char * const SPREAD_METHOD_NAME; // Property::String  "pad | reflect | repeat"
+
+//mesh visual
+extern const char * const OBJECT_URL_NAME;
+extern const char * const MATERIAL_URL_NAME;
+extern const char * const TEXTURES_PATH_NAME;
+extern const char * const SHADING_MODE_NAME;
+extern const char * const USE_MIPMAPPING_NAME;
+extern const char * const USE_SOFT_NORMALS_NAME;
+extern const char * const LIGHT_POSITION_NAME;
+
+//Primitive properties
+extern const char * const PRIMITIVE_SHAPE;
+extern const char * const SLICES;
+extern const char * const STACKS;
+extern const char * const SCALE_TOP_RADIUS;
+extern const char * const SCALE_BOTTOM_RADIUS;
+extern const char * const SCALE_HEIGHT;
+extern const char * const SCALE_RADIUS;
+extern const char * const SCALE_DIMENSIONS;
+extern const char * const BEVEL_PERCENTAGE;
+extern const char * const BEVEL_SMOOTHNESS;
+extern const char * const LIGHT_POSITION_UNIFORM_NAME;
 
 } // namespace Internal
 
index 7309a54..1ece1d1 100644 (file)
@@ -30,7 +30,7 @@ namespace Toolkit
 {
 
 const unsigned int TOOLKIT_MAJOR_VERSION = 1;
-const unsigned int TOOLKIT_MINOR_VERSION = 5;
+const unsigned int TOOLKIT_MINOR_VERSION = 9;
 const unsigned int TOOLKIT_MICRO_VERSION = 0;
 const char * const TOOLKIT_BUILD_DATE    = __DATE__ " " __TIME__;
 
index bac38ef..77aff09 100644 (file)
@@ -1,6 +1,6 @@
 Name:       dali-toolkit
 Summary:    Dali 3D engine Toolkit
-Version:    1.5.0
+Version:    1.9.0
 Release:    1
 Group:      System/Libraries
 License:    Apache-2.0 and BSD-3-Clause and MIT