/*
- * 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.
mObserverCalled = true;
}
+ virtual void LoadComplete( bool loadSuccess, Devel::PixelBuffer pixelBuffer, const VisualUrl& url, bool preMultiplied ) override
+ {
+ mLoaded = loadSuccess;
+ mObserverCalled = true;
+ }
+
bool mLoaded;
bool mObserverCalled;
};
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;
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 );
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);
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);
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);
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);
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);
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);
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);
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);
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;
/*
- * 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.
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;
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 );
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 );
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 );
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;
+}
/*
- * 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/devel-api/adaptor-framework/image-loading.h>
#include "dummy-control.h"
+#include <dali/integration-api/debug.h>
+
using namespace Dali;
using namespace Dali::Toolkit;
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
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 );
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 );
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 );
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 );
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 );
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 );
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 );
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 );
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 );
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 );
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();
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 );
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 );
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 )
{
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 );
/**
* @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.
* @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
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 )
{
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 );
/*
- * 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.
}
}
+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
#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.
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;
/*
- * 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.
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
#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.
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
}
else
{
- shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
+ shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true, false );
}
Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
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");
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 )
{
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 );
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 )
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 ) );
}\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()
{
}
-Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
+Shader ImageVisualShaderFactory::GetShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping, bool roundedCorner )
{
Shader shader;
if( atlasing )
}
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 );
+ }
}
}
* @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.
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 )
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
{
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 )
{
: 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);
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() )
{
#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.
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();
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.
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 )
/*
- * 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.
// 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>
}
}
+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()
{
}
-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 )
{
// 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 )
#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
{
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
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:
/**
* @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
/*
- * 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.
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
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 );
}
}
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 )
{
{
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 )
// 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()
NPatchVisual::NPatchVisual( VisualFactoryCache& factoryCache )
: Visual::Base( factoryCache, Visual::FittingMode::FILL ),
+ mPlacementActor(),
mLoader( factoryCache.GetNPatchLoader() ),
mImageUrl(),
mAuxiliaryUrl(),
{
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 )
{
const NPatchLoader::Data* data;
TextureSet textureSet;
- if( mLoader.GetNPatchData( mId, data ) )
+ if( mLoader.GetNPatchData( mId, data ) && data->loadCompleted )
{
textureSet = data->textureSet;
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
#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>
* | auxiliaryImage | STRING |
* | auxiliaryImageAlpha | FLOAT |
*/
-class NPatchVisual: public Visual::Base
+class NPatchVisual: public Visual::Base, public TextureUploadObserver
{
public:
*/
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
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
mWidth( width ),
mHeight( height )
{
+ mRasterizer = nsvgCreateRasterizer();
+}
+
+RasterizingTask::~RasterizingTask()
+{
+ nsvgDeleteRasterizer( mRasterizer );
}
void RasterizingTask::Load()
}
}
-void RasterizingTask::Rasterize( NSVGrasterizer* rasterizer )
+void RasterizingTask::Rasterize( )
{
if( mParsedSvg != NULL && mWidth > 0u && mHeight > 0u )
{
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 );
: mTrigger( trigger ),
mIsThreadWaiting( false )
{
- mRasterizer = nsvgCreateRasterizer();
}
SvgRasterizeThread::~SvgRasterizeThread()
{
-
- nsvgDeleteRasterizer( mRasterizer );
delete mTrigger;
}
while( RasterizingTaskPtr task = NextTaskToProcess() )
{
task->Load( );
- task->Rasterize( mRasterizer );
+ task->Rasterize( );
AddCompletedTask( task );
}
}
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
float mDpi;
unsigned int mWidth;
unsigned int mHeight;
+ NSVGrasterizer* mRasterizer;
};
/**
Dali::Mutex mMutex;
EventThreadCallback* mTrigger;
- NSVGrasterizer* mRasterizer;
bool mIsThreadWaiting;
};
// 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>
// EXTERNAL INCLUDES
#include <dali/public-api/common/stage.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
// 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 )
{
DoSetProperty( Toolkit::ImageVisual::Property::ATLASING, keyValue.second );
}
+ else if( keyValue.first == SYNCHRONOUS_LOADING )
+ {
+ DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
+ }
}
}
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;
+ }
}
}
Shader shader;
if( !mImpl->mCustomShader )
{
- shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true );
+ shader = mImageVisualShaderFactory.GetShader( mFactoryCache, mAttemptAtlasing, true, false );
}
else
{
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 );
+ }
}
}
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(
}
}
+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,
{
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(
{
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 )
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(
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,
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",
break;
}
case TextureManager::LOAD_FINISHED:
- // Loading has already completed. Do nothing.
+ // Loading has already completed.
+ if( observer && textureInfo.loadPixelBuffer )
+ {
+ LoadOrQueueTexture( textureInfo, observer );
+ }
break;
}
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 );
{
// No atlas support for now
textureInfo.useAtlas = NO_ATLAS;
+ textureInfo.preMultiplied = pixelBuffer.IsAlphaPreMultiplied();
if( textureInfo.storageType == UPLOAD_TO_TEXTURE )
{
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 );
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.
mQueueLoadFlag = false;
ProcessQueuedTextures();
+
+ if( info->loadPixelBuffer && info->observerList.Count() == 0 )
+ {
+ Remove( info->textureId, nullptr );
+ }
}
TextureManager::TextureId TextureManager::GenerateUniqueTextureId()
#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.
// 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.
TextureUploadObserver* observer,
bool orientationCorrection,
TextureManager::ReloadPolicy reloadPolicy,
- MultiplyOnLoad& preMultiplyOnLoad );
+ MultiplyOnLoad& preMultiplyOnLoad,
+ bool loadPixelBuffer );
/**
* @brief Get the current state of a texture
UseAtlas useAtlas,
TextureManager::TextureHash hash,
bool orientationCorrection,
- bool preMultiplyOnLoad )
+ bool preMultiplyOnLoad,
+ bool loadPixelBuffer )
: url( url ),
desiredSize( desiredSize ),
useSize( desiredSize ),
cropToMask( cropToMask ),
orientationCorrection( true ),
preMultiplyOnLoad( preMultiplyOnLoad ),
- preMultiplied( false )
+ preMultiplied( false ),
+ loadPixelBuffer( loadPixelBuffer )
{
}
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
};
/**
#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
{
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).
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 )
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;
{
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 )
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;
+ }
}
}
{
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
{
DoSetOffStage( actor );
mImpl->mMixColorIndex = Property::INVALID_INDEX;
+ mImpl->mCornerRadiusIndex = Property::INVALID_INDEX;
mImpl->mFlags &= ~Impl::IS_ON_STAGE;
}
}
// 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
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
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;
*/
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:
/**
*/
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:
/**
enum ShaderType
{
COLOR_SHADER,
+ COLOR_SHADER_ROUNDED_CORNER,
BORDER_SHADER,
BORDER_SHADER_ANTI_ALIASING,
GRADIENT_SHADER_LINEAR_USER_SPACE,
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,
// 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" );
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
// 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;
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
{
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__;
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
projects / platform / core / uifw / dali-toolkit.git / commitdiff