}
template <>
+inline bool CompareType<Extents>(Extents extents1, Extents extents2, float epsilon)
+{
+ return (extents1.start == extents2.start) &&
+ (extents1.end == extents2.end) &&
+ (extents1.top == extents2.top) &&
+ (extents1.bottom == extents2.bottom);
+}
+
+template <>
inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
{
Property::Type type = q1.GetType();
result = false;
break;
}
+ case Property::EXTENTS:
+ {
+ Extents a, b;
+ q1.Get(a);
+ q2.Get(b);
+ result = CompareType<Extents>( a, b, epsilon );
+ break;
+ }
case Property::NONE:
{
result = false;
////////////////////////////////////////////////////////////////////////////////////////////////////
+bool ToolkitApplication::DECODED_IMAGES_SUPPORTED;
+
ToolkitApplication::ToolkitApplication()
: mApplicationStub(new Application(*this))
{
// The Application Stub
Application* mApplicationStub;
friend class Application;
+
+public: // Test static member
+ static bool DECODED_IMAGES_SUPPORTED;
};
} // namespace Dali
*
*/
-// CLASS HEADER
-#include "toolkit-video-player.h"
-
-// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/video-player.h>
#include <dali/public-api/object/any.h>
+#include <dali/public-api/object/base-object.h>
+#include <toolkit-application.h>
namespace Dali
{
{
}
+bool VideoPlayer::IsVideoTextureSupported() const
+{
+ return ToolkitApplication::DECODED_IMAGES_SUPPORTED;
+}
+
} // namespace Dali;
+++ /dev/null
-#ifndef __DALI_TOOLKIT_VIDEO_PLAYER_H__
-#define __DALI_TOOLKIT_VIDEO_PLAYER_H__
-
-/*
- * Copyright (c) 2016 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/object/base-object.h>
-
-#include <dali/devel-api/adaptor-framework/video-player-plugin.h>
-
-namespace Dali
-{
-
-class Any;
-
-namespace Internal
-{
-namespace Adaptor
-{
-
-class VideoPlayer;
-
-}
-}
-
-/**
- * @brief VideoPlayer class is used for video playback.
- * @SINCE_1_1.38
- */
-class VideoPlayer: public BaseHandle
-{
-public:
-
- VideoPlayer();
-
- ~VideoPlayer();
-
- static VideoPlayer New();
-
- VideoPlayer( const VideoPlayer& player );
-
- VideoPlayer& operator=( const VideoPlayer& player );
-
- static VideoPlayer DownCast( BaseHandle handle );
-
- void SetUrl( const std::string& url );
-
- std::string GetUrl();
-
- void SetLooping(bool looping);
-
- bool IsLooping();
-
- void Play();
-
- void Pause();
-
- void Stop();
-
- void SetMute( bool mute );
-
- bool IsMuted();
-
- void SetVolume( float left, float right );
-
- void GetVolume( float& left, float& right );
-
- void SetRenderingTarget( Any target );
-
- void SetPlayPosition( int millisecond );
-
- int GetPlayPosition();
-
- void SetDisplayArea( DisplayArea area );
-
- void SetDisplayRotation( Dali::VideoPlayerPlugin::DisplayRotation rotation );
-
- Dali::VideoPlayerPlugin::DisplayRotation GetDisplayRotation();
-
- Dali::VideoPlayerPlugin::VideoPlayerSignalType& FinishedSignal();
-
- void Forward( int millisecond );
-
- void Backward( int millisecond );
-
-private:
-
- VideoPlayer( Internal::Adaptor::VideoPlayer* internal );
-
-};
-
-} // namespace Dali;
-
-#endif
"\"sensitive\": { \"typeCast\":\"boolean\", \"value\":false },"
"\"orientation\": { \"typeCast\":\"rotation\", \"value\":[10,10,10,10] },"
"\"colorMode\": { \"typeCast\":\"string\", \"value\":\"USE_OWN_MULTIPLY_PARENT_COLOR\" },"
- "\"clippingBox\": { \"typeCast\":\"rect\", \"value\":[10,10,10,10] }"
+ "\"clippingBox\": { \"typeCast\":\"rect\", \"value\":[10,10,10,10] },"
+ "\"padding\": { \"typeCast\":\"extents\", \"value\":[10,10,10,10] }"
"}]"
"}"
);
END_TEST;
}
+
+int UtcDaliControlMarginProperty(void)
+{
+ ToolkitTestApplication application;
+
+ Control control = Control::New();
+ control.SetBackgroundColor( Color::BLUE );
+
+ control.SetProperty( Control::Property::MARGIN, Extents( 20, 10, 0, 0 ) );
+
+ Stage::GetCurrent().Add( control );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( control.GetProperty<Extents>( Control::Property::MARGIN ), Extents( 20, 10, 0, 0 ), TEST_LOCATION );
+
+ // Parent control has one ImageView as a Child.
+ ImageView image = ImageView::New();
+ image.SetBackgroundColor( Color::RED );
+ image.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ image.SetProperty( Control::Property::PADDING, Extents( 10, 10, 10, 10 ) );
+ control.Add( image );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( image.GetProperty<Extents>( Control::Property::PADDING ), Extents( 10, 10, 10, 10 ), TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliControlPaddingProperty(void)
+{
+ ToolkitTestApplication application;
+
+ Control control = Control::New();
+ control.SetBackgroundColor( Color::BLUE );
+
+ control.SetProperty( Control::Property::PADDING, Extents( 10, 10, 10, 10 ) );
+
+ Stage::GetCurrent().Add( control );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( control.GetProperty<Extents>( Control::Property::PADDING ), Extents( 10, 10, 10, 10 ), TEST_LOCATION );
+
+ END_TEST;
+}
ImageView imageView = ImageView::New();
imageView.SetProperty( ImageView::Property::IMAGE, imageMap );
+ imageView.SetProperty( Toolkit::Control::Property::PADDING, Extents( 10u, 10u, 10u, 10u ) );
// By default, Aysnc loading is used
// loading is not started if the actor is offStage
#include <dali-toolkit-test-suite-utils.h>
#include <toolkit-timer.h>
#include <toolkit-event-thread-callback.h>
-#include <dali/devel-api/images/nine-patch-image.h>
#include <dali/devel-api/object/handle-devel.h>
#include <dali-toolkit/devel-api/visual-factory/transition-data.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
#include <dali-toolkit/dali-toolkit.h>
#include "dummy-control.h"
DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
DALI_TEST_EQUALS( actor.IsResourceReady(), true, TEST_LOCATION );
+ dummyImpl.UnregisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1 );
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+
END_TEST;
}
END_TEST;
}
+
+int UtcDaliImageVisualReleasePolicy01(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy01 Detached Policy, disabling visual with this policy deletes texture" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ Property::Map propertyMap;
+ propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMap.Insert( DevelImageVisual::Property::RELEASE_POLICY, DevelImageVisual::ReleasePolicy::DETACHED );
+
+ Visual::Base imageVisual = factory.CreateVisual(propertyMap);
+ DALI_TEST_CHECK( imageVisual );
+
+ // Set up debug trace
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visual with control and ensure it has the only handle" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
+ imageVisual.Reset();
+
+ actor.SetSize(200.f, 200.f);
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ // Test renderer and texture created
+ tet_infoline( "Confirm texture created" );
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+
+ tet_infoline( "Disable visual causing the texture to be deleted" );
+ dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
+
+ application.SendNotification();
+ application.Render(0);
+ // Test renderer and textures removed.
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy02(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy02 Destroyed Policy, Texture should be deleted when visual destroyed" );
+
+ VisualFactory factory = VisualFactory::Get();
+ const std::string MASK_IMAGE = TEST_REMOTE_IMAGE_FILE_NAME;
+
+ Property::Map propertyMap;
+ propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
+ propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMap.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::DESTROYED );
+
+ Visual::Base imageVisual = factory.CreateVisual(propertyMap);
+ DALI_TEST_CHECK( imageVisual );
+
+ // Setup debug trace
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visual with control and ensure it has the only handle" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
+ imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
+
+ actor.SetSize(200.f, 200.f);
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ // Test renderer and texture created
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+
+
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ tet_infoline( "Destroy visual by UnRegistering visual with control, check renderer is destroyed" );
+ dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ application.SendNotification();
+ application.Render();
+
+ // Test texture removed after visual destroyed.
+ tet_infoline( "Ensure texture is deleted after visual destroyed" );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy03(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy03 Never Policy, texture should not be deleted after visual destroyed" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ Property::Map propertyMap;
+ propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMap.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::NEVER );
+
+ Visual::Base imageVisual = factory.CreateVisual(propertyMap);
+ DALI_TEST_CHECK( imageVisual );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visual with control and ensure it has the only handle" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
+ imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
+
+ actor.SetSize(200.f, 200.f);
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ // Test renderer and texture created
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+
+ tet_infoline( "Destroy visual by UnRegistering visual with control, check renderer is destroyed" );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Ensure texture is not deleted as policy is set to NEVER" );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy04(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy04 Two visuals with different policies sharing a texture" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ tet_infoline( "Create first visual with Never release policy" );
+ Property::Map propertyMapNeverReleasePolicy;
+ propertyMapNeverReleasePolicy.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMapNeverReleasePolicy.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::NEVER );
+ Visual::Base imageVisualNever = factory.CreateVisual( propertyMapNeverReleasePolicy );
+
+ tet_infoline( "Create second visual with Destroyed release policy");
+ Property::Map propertyMapDestroyedReleasePolicy;
+ propertyMapDestroyedReleasePolicy.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMapDestroyedReleasePolicy.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::DESTROYED );
+ Visual::Base imageVisualDestroyed = factory.CreateVisual( propertyMapDestroyedReleasePolicy );
+
+ // Set up trace debug
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visuals with control and ensure it has the only handles" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisualNever );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, imageVisualDestroyed );
+ imageVisualNever.Reset(); // reduce ref count so only the control keeps the visual alive.
+ imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
+
+ actor.SetSize(200.f, 200.f);
+
+ // Test initially zero renderers
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ tet_infoline( "Ensure a texture is created, shared amongst both visuals. Each visual has its own renderer" );
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+
+ // Test renderer removed when visual destroyed
+ DALI_TEST_CHECK( actor.GetRendererCount() == 2u );
+ dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL2 ); // TEST_VISUAL2 no longer requires the texture as release policy DESTROYED
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ application.SendNotification();
+ application.Render();
+
+ // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+
+ dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Ensure a texture is not deleted as second visual used the NEVER release policy" );
+ // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy05(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy05 Testing settung by string currents correct enum" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ Property::Map propertyMapNeverReleasePolicy;
+ propertyMapNeverReleasePolicy.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMapNeverReleasePolicy.Insert( "releasePolicy" , "never" );
+
+ Visual::Base imageVisualNever = factory.CreateVisual( propertyMapNeverReleasePolicy );
+
+ Property::Map resultMap;
+ imageVisualNever.CreatePropertyMap( resultMap );
+ DALI_TEST_CHECK( ! resultMap.Empty() );
+
+ DALI_TEST_EQUALS( ( resultMap.Find( DevelImageVisual::Property::RELEASE_POLICY ) )->Get<int>(), (int)DevelImageVisual::ReleasePolicy::NEVER, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy06(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy06 Never Policy, texture should not be affected by Disabling and Enabling visual" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ Property::Map propertyMap;
+ propertyMap.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMap.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::NEVER );
+
+ Visual::Base imageVisual = factory.CreateVisual(propertyMap);
+ DALI_TEST_CHECK( imageVisual );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visual with control and ensure it has the only handle" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
+ imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
+
+ actor.SetSize(200.f, 200.f);
+
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ // Test renderer and texture created
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+ textureTrace.Reset();
+
+ tet_infoline( "Disable Visual and check texture not affected" );
+ dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
+ application.SendNotification();
+ application.Render(0);
+ tet_infoline( "Check renderer is destroyed when visual off stage" );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+ textureTrace.Reset();
+
+ tet_infoline( "Re-enable Visual and check texture not affected" );
+ dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
+ application.SendNotification();
+ application.Render(0);
+ tet_infoline( "Check texture not affected and renderer is destroyed when visual off stage" );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliImageVisualReleasePolicy07(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliImageVisualReleasePolicy07 Two visuals with different policies sharing a texture DETACHED and DESTROYED" );
+
+ VisualFactory factory = VisualFactory::Get();
+
+ tet_infoline( "Create first visual with DESTROYED release policy" );
+ Property::Map propertyMapNeverReleasePolicy;
+ propertyMapNeverReleasePolicy.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMapNeverReleasePolicy.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::DESTROYED );
+ Visual::Base imageVisualDestroyed = factory.CreateVisual( propertyMapNeverReleasePolicy );
+
+ tet_infoline( "Create second visual with DETACHED release policy");
+ Property::Map propertyMapDestroyedReleasePolicy;
+ propertyMapDestroyedReleasePolicy.Insert( Visual::Property::TYPE, Visual::IMAGE );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH, 20 );
+ propertyMapDestroyedReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT, 30 );
+ propertyMapDestroyedReleasePolicy.Insert( DevelImageVisual::Property::RELEASE_POLICY , DevelImageVisual::ReleasePolicy::DETACHED );
+ Visual::Base imageVisualDetached = factory.CreateVisual( propertyMapDestroyedReleasePolicy );
+
+ // Set up trace debug
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ tet_infoline( "Register visuals with control and ensure it has the only handles" );
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisualDestroyed );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, imageVisualDetached );
+ imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
+ imageVisualDetached.Reset(); // reduce ref count so only the control keeps the visual alive.
+
+ actor.SetSize(200.f, 200.f);
+
+ // Test initially zero renderers
+ application.SendNotification();
+ application.Render(0);
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
+
+ Stage::GetCurrent().Add( actor );
+
+ // Wait for image to load
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ application.SendNotification();
+ application.Render(0);
+ tet_infoline( "Ensure a texture is created, shared amongst both visuals. Each visual has its own renderer" );
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
+
+ // Test renderer removed when visual destroyed
+ DALI_TEST_CHECK( actor.GetRendererCount() == 2u );
+ dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL2, false ); // TEST_VISUAL2 no longer requires the texture as release policy DETACHED
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ application.SendNotification();
+ application.Render();
+
+ // Test texture was not deleted as TEST_VISUAL release policy is DESTROYED and is still required.
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+
+ dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+ application.SendNotification();
+ application.Render();
+
+ tet_infoline( "Ensure a texture is not deleted as second visual used the DESTROYED release policy" );
+ DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
+
+ END_TEST;
+}
{
const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
- Property::Value* valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
+ Property::Value* valueSet = NULL;
+ if ( valueGet.first.type == Property::Key::INDEX )
+ {
+ valueSet = fontStyleMapSet.Find( valueGet.first.indexKey );
+ }
+ else
+ {
+ // Get Key is a string so searching Set Map for a string key
+ valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
+ }
+
if( NULL != valueSet )
{
if( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() )
}
else
{
- tet_printf( " The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
+ if ( valueGet.first.type == Property::Key::INDEX )
+ {
+ tet_printf( " The key %d doesn't exist.", valueGet.first.indexKey );
+ }
+ else
+ {
+ tet_printf( " The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
+ }
return false;
}
}
Property::Map placeholderPixelSizeMapSet;
Property::Map placeholderPixelSizeMapGet;
Property::Map placeholderFontstyleMap;
- placeholderPixelSizeMapSet["placeholderText"] = "Setting Placeholder Text";
- placeholderPixelSizeMapSet["placeholderTextFocused"] = "Setting Placeholder Text Focused";
- placeholderPixelSizeMapSet["placeholderColor"] = Color::BLUE;
- placeholderPixelSizeMapSet["placeholderFontFamily"] = "Arial";
- placeholderPixelSizeMapSet["placeholderPixelSize"] = 15.0f;
+ placeholderPixelSizeMapSet["text"] = "Setting Placeholder Text";
+ placeholderPixelSizeMapSet["textFocused"] = "Setting Placeholder Text Focused";
+ placeholderPixelSizeMapSet["color"] = Color::BLUE;
+ placeholderPixelSizeMapSet["fontFamily"] = "Arial";
+ placeholderPixelSizeMapSet["pixelSize"] = 15.0f;
placeholderFontstyleMap.Insert( "weight", "bold" );
- placeholderPixelSizeMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderPixelSizeMapSet["fontStyle"] = placeholderFontstyleMap;
editor.SetProperty( TextEditor::Property::PLACEHOLDER, placeholderPixelSizeMapSet );
placeholderPixelSizeMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderPixelSizeMapGet.Count(), placeholderPixelSizeMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderPixelSizeMapSet ), true, TEST_LOCATION );
+
+ tet_infoline("Test Placeholder settings set as strings is converted correctly to Property Index key and holds set value");
+ Property::Map placeholderConversionMap;
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderPixelSizeMapSet["text"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderPixelSizeMapSet["textFocused"] ;
+ placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderPixelSizeMapSet["color"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderPixelSizeMapSet["fontFamily"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::PIXEL_SIZE ] = placeholderPixelSizeMapSet["pixelSize"];
+
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderConversionMap ), true, TEST_LOCATION );
// Check the placeholder property with point size
Property::Map placeholderMapSet;
Property::Map placeholderMapGet;
- placeholderMapSet["placeholderText"] = "Setting Placeholder Text";
- placeholderMapSet["placeholderTextFocused"] = "Setting Placeholder Text Focused";
- placeholderMapSet["placeholderColor"] = Color::RED;
- placeholderMapSet["placeholderFontFamily"] = "Arial";
- placeholderMapSet["placeholderPointSize"] = 12.0f;
-
+ placeholderMapSet["text"] = "Setting Placeholder Text";
+ placeholderMapSet["textFocused"] = "Setting Placeholder Text Focused";
+ placeholderMapSet["color"] = Color::RED;
+ placeholderMapSet["fontFamily"] = "Arial";
+ placeholderMapSet["pointSize"] = 12.0f;
// Check the placeholder font style property
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "weight", "bold" );
placeholderFontstyleMap.Insert( "width", "condensed" );
placeholderFontstyleMap.Insert( "slant", "italic" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
editor.SetProperty( TextEditor::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ tet_infoline("Test Placeholder settings set as strings is converted correctly to Property Index key and holds set value");
+ placeholderConversionMap.Clear();
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderMapSet["text"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderMapSet["textFocused"] ;
+ placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderMapSet["color"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderMapSet["fontFamily"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::POINT_SIZE ] = placeholderMapSet["pointSize"];
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
// Reset font style.
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "weight", "normal" );
placeholderFontstyleMap.Insert( "slant", "oblique" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
editor.SetProperty( TextEditor::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderMapSet["fontStyle"];
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "slant", "roman" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
editor.SetProperty( TextEditor::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::PLACEHOLDER );
placeholderFontstyleMap.Clear();
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
editor.SetProperty( TextEditor::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderMapSet["fontStyle"];
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
END_TEST;
}
Property::Map placeholderPixelSizeMapSet;
Property::Map placeholderPixelSizeMapGet;
Property::Map placeholderFontstyleMap;
- placeholderPixelSizeMapSet["placeholderText"] = "Setting Placeholder Text";
- placeholderPixelSizeMapSet["placeholderTextFocused"] = "Setting Placeholder Text Focused";
- placeholderPixelSizeMapSet["placeholderColor"] = Color::BLUE;
- placeholderPixelSizeMapSet["placeholderFontFamily"] = "Arial";
- placeholderPixelSizeMapSet["placeholderPixelSize"] = 15.0f;
- placeholderPixelSizeMapSet["placeholderEllipsis"] = true;
+ placeholderPixelSizeMapSet["text"] = "Setting Placeholder Text";
+ placeholderPixelSizeMapSet["textFocused"] = "Setting Placeholder Text Focused";
+ placeholderPixelSizeMapSet["color"] = Color::BLUE;
+ placeholderPixelSizeMapSet["fontFamily"] = "Arial";
+ placeholderPixelSizeMapSet["pixelSize"] = 15.0f;
+ placeholderPixelSizeMapSet["ellipsis"] = true;
placeholderFontstyleMap.Insert( "weight", "bold" );
placeholderPixelSizeMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
placeholderPixelSizeMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderPixelSizeMapGet.Count(), placeholderPixelSizeMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderPixelSizeMapSet ), true, TEST_LOCATION );
+
+ tet_infoline("Test Placeholder settings set as strings is converted correctly to Property Index key and holds set value");
+ Property::Map placeholderConversionMap;
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderPixelSizeMapSet["text"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderPixelSizeMapSet["textFocused"] ;
+ placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderPixelSizeMapSet["color"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderPixelSizeMapSet["fontFamily"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::PIXEL_SIZE ] = placeholderPixelSizeMapSet["pixelSize"];
+
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderConversionMap ), true, TEST_LOCATION );
// Check the placeholder property with point size
Property::Map placeholderMapSet;
Property::Map placeholderMapGet;
- placeholderMapSet["placeholderText"] = "Setting Placeholder Text";
- placeholderMapSet["placeholderTextFocused"] = "Setting Placeholder Text Focused";
- placeholderMapSet["placeholderColor"] = Color::RED;
- placeholderMapSet["placeholderFontFamily"] = "Arial";
- placeholderMapSet["placeholderPointSize"] = 12.0f;
- placeholderMapSet["placeholderEllipsis"] = false;
+ placeholderMapSet["text"] = "Setting Placeholder Text";
+ placeholderMapSet["textFocused"] = "Setting Placeholder Text Focused";
+ placeholderMapSet["color"] = Color::RED;
+ placeholderMapSet["fontFamily"] = "Arial";
+ placeholderMapSet["pointSize"] = 12.0f;
+ placeholderMapSet["ellipsis"] = false;
// Check the placeholder font style property
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "weight", "bold" );
placeholderFontstyleMap.Insert( "width", "condensed" );
placeholderFontstyleMap.Insert( "slant", "italic" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ placeholderConversionMap.Clear();
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderPixelSizeMapSet["text"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderPixelSizeMapSet["textFocused"] ;
+ placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderPixelSizeMapSet["color"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderPixelSizeMapSet["fontFamily"];
+ placeholderConversionMap[ Text::PlaceHolder::Property::POINT_SIZE ] = placeholderPixelSizeMapSet["pointSize"];
+
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
// Reset font style.
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "weight", "normal" );
placeholderFontstyleMap.Insert( "slant", "oblique" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
placeholderFontstyleMap.Clear();
placeholderFontstyleMap.Insert( "slant", "roman" );
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
+
field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
placeholderFontstyleMap.Clear();
- placeholderMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
+ placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
+ placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
// Check the ellipsis property
DALI_TEST_CHECK( !field.GetProperty<bool>( TextField::Property::ELLIPSIS ) );
END_TEST;
}
+
+int UtcDaliTextFieldSettingPlaceholder(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline("UtcDaliTextFieldSettingPlaceholder");
+
+ TextField field = TextField::New();
+ DALI_TEST_CHECK( field );
+ Stage::GetCurrent().Add( field );
+
+ // Check the placeholder property with pixel size
+ Property::Map placeholderPixelSizeMapSet;
+ Property::Map placeholderPixelSizeMapGet;
+ Property::Map placeholderFontstyleMap;
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::TEXT ] = "Setting Placeholder Text";
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = "Setting Placeholder Text Focused";
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::COLOR ] = Color::BLUE;
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::FONT_FAMILY ] = "Arial";
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::PIXEL_SIZE ] = 15.0f;
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::ELLIPSIS ] = true;
+
+ placeholderFontstyleMap.Insert( "weight", "bold" );
+ placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
+ field.SetProperty( TextField::Property::PLACEHOLDER, placeholderPixelSizeMapSet );
+
+ placeholderPixelSizeMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
+ DALI_TEST_EQUALS( placeholderPixelSizeMapGet.Count(), placeholderPixelSizeMapSet.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderPixelSizeMapSet ), true, TEST_LOCATION );
+
+ // Check the placeholder property with point size
+ Property::Map placeholderMapSet;
+ Property::Map placeholderMapGet;
+ placeholderMapSet[ Text::PlaceHolder::Property::TEXT ] = "Setting Placeholder Text";
+ placeholderMapSet[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = "Setting Placeholder Text Focused";
+ placeholderMapSet[ Text::PlaceHolder::Property::COLOR ] = Color::RED;
+ placeholderMapSet[ Text::PlaceHolder::Property::FONT_FAMILY ] = "Arial";
+ placeholderMapSet[ Text::PlaceHolder::Property::POINT_SIZE ] = 12.0f;
+ placeholderMapSet[ Text::PlaceHolder::Property::ELLIPSIS ] = false;
+
+ // Check the placeholder font style property
+ placeholderFontstyleMap.Clear();
+
+ placeholderFontstyleMap.Insert( "weight", "bold" );
+ placeholderFontstyleMap.Insert( "width", "condensed" );
+ placeholderFontstyleMap.Insert( "slant", "italic" );
+ placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
+ field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
+
+ placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
+ DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ // Reset font style.
+ placeholderFontstyleMap.Clear();
+ placeholderFontstyleMap.Insert( "weight", "normal" );
+ placeholderFontstyleMap.Insert( "slant", "oblique" );
+ placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
+ field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
+
+ placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
+ DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ placeholderFontstyleMap.Clear();
+ placeholderFontstyleMap.Insert( "slant", "roman" );
+ placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
+ field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
+
+ placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
+
+ placeholderFontstyleMap.Clear();
+ placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
+
+ field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
+ placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
+ DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
+
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliVideoViewPropertyUnderlay(void)
+{
+ ToolkitTestApplication application;
+ ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
+
+ VideoView view = VideoView::New();
+ DALI_TEST_CHECK( view );
+
+ Stage::GetCurrent().Add( view );
+
+ application.SendNotification();
+ application.Render();
+
+ bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
+ DALI_TEST_CHECK( isUnderlay );
+
+ view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
+ isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
+ DALI_TEST_CHECK( !isUnderlay );
+
+ view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
+ isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
+ DALI_TEST_CHECK( isUnderlay );
+
+ // If platform api doesn't provide any API or feature for decoded images of video,
+ // UNDERLAY should be true
+ ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
+
+ view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
+ isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
+ DALI_TEST_CHECK( isUnderlay );
+
+ END_TEST;
+}
#include <dali-toolkit/public-api/controls/slider/slider.h>
#include <dali-toolkit/public-api/controls/table-view/table-view.h>
#include <dali-toolkit/public-api/controls/text-controls/hidden-input-properties.h>
+#include <dali-toolkit/public-api/controls/text-controls/placeholder-properties.h>
#include <dali-toolkit/public-api/controls/text-controls/text-editor.h>
#include <dali-toolkit/public-api/controls/text-controls/text-field.h>
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
BACKGROUND_IMAGE = Control::Property::BACKGROUND_IMAGE,
KEY_INPUT_FOCUS = Control::Property::KEY_INPUT_FOCUS,
BACKGROUND = Control::Property::BACKGROUND,
+ MARGIN = Control::Property::MARGIN,
+ PADDING = Control::Property::PADDING,
/**
* @brief Displays a tooltip when the control is hovered over.
* @note When retrieved, a Property::MAP is returned.
* @see Toolkit::Tooltip
*/
- TOOLTIP = BACKGROUND + 1,
+ TOOLTIP = PADDING + 1,
/**
* @brief The current state of the control.
*
* @see DevelControl::State
*/
- STATE = BACKGROUND + 2,
+ STATE = PADDING + 2,
/**
* @brief The current sub state of the control.
*
* @see DevelControl::State
*/
- SUB_STATE = BACKGROUND + 3,
+ SUB_STATE = PADDING + 3,
/**
* @brief The actor ID of the left focusable control.
* @details Name "leftFocusableActorId", type Property::INTEGER.
*
*/
- LEFT_FOCUSABLE_ACTOR_ID = BACKGROUND + 4,
+ LEFT_FOCUSABLE_ACTOR_ID = PADDING + 4,
/**
* @brief The actor ID of the right focusable control.
* @details Name "rightFocusableActorId", type Property::INTEGER.
*
*/
- RIGHT_FOCUSABLE_ACTOR_ID = BACKGROUND + 5,
+ RIGHT_FOCUSABLE_ACTOR_ID = PADDING + 5,
/**
* @brief The actor ID of the up focusable control.
* @details Name "upFocusableActorId", type Property::INTEGER.
*
*/
- UP_FOCUSABLE_ACTOR_ID = BACKGROUND + 6,
+ UP_FOCUSABLE_ACTOR_ID = PADDING + 6,
/**
* @brief The actor ID of the down focusable control.
* @details Name "downFocusableActorId", type Property::INTEGER.
*
*/
- DOWN_FOCUSABLE_ACTOR_ID = BACKGROUND + 7
+ DOWN_FOCUSABLE_ACTOR_ID = PADDING + 7
};
} // namespace Property
devel_api_header_files = \
$(devel_api_src_dir)/direction-enums.h
+devel_api_visuals_header_files = \
+ $(devel_api_src_dir)/visuals/image-visual-properties-devel.h
+
devel_api_controls_header_files = \
$(devel_api_src_dir)/controls/control-depth-index-ranges.h \
$(devel_api_src_dir)/controls/control-devel.h \
--- /dev/null
+#ifndef DALI_TOOLKIT_DEVEL_API_VISUALS_IMAGE_VISUAL_PROPERTIES_DEVEL_H
+#define DALI_TOOLKIT_DEVEL_API_VISUALS_IMAGE_VISUAL_PROPERTIES_DEVEL_H
+
+/*
+ * Copyright (c) 2017 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace DevelImageVisual
+{
+
+
+/**
+ * @brief The policy determining when a image is deleted from the cache in relation to the ImageVisual lifetime.
+ * @note If the texture is being shared by another visual it persist if still required.
+ */
+namespace ReleasePolicy
+{
+
+/**
+ * @brief The available named elements that define the ReleasePolicy.
+ */
+enum Type
+{
+ DETACHED = 0, ///< Image deleted from cache when ImageVisual detached from stage.
+ DESTROYED, ///< Image deleted from cache when ImageVisual destroyed.
+ NEVER ///< Image is never deleted, will survive the lifetime of the application.
+};
+
+} // namespace ReleasePolicy;
+
+namespace Property
+{
+
+enum Type
+{
+ URL = Dali::Toolkit::ImageVisual::Property::URL,
+ FITTING_MODE = Dali::Toolkit::ImageVisual::Property::FITTING_MODE,
+ SAMPLING_MODE = Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE,
+ DESIRED_WIDTH = Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH,
+ DESIRED_HEIGHT = Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT,
+ SYNCHRONOUS_LOADING = Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING,
+ BORDER_ONLY = Dali::Toolkit::ImageVisual::Property::BORDER_ONLY,
+ PIXEL_AREA = Dali::Toolkit::ImageVisual::Property::PIXEL_AREA,
+ WRAP_MODE_U = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U,
+ WRAP_MODE_V = Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V,
+ BORDER = Dali::Toolkit::ImageVisual::Property::BORDER,
+ ATLASING = Dali::Toolkit::ImageVisual::Property::ATLASING,
+ ALPHA_MASK_URL = Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL,
+ BATCH_SIZE = Dali::Toolkit::ImageVisual::Property::BATCH_SIZE,
+ CACHE_SIZE = Dali::Toolkit::ImageVisual::Property::CACHE_SIZE,
+ FRAME_DELAY = Dali::Toolkit::ImageVisual::Property::FRAME_DELAY,
+ MASK_CONTENT_SCALE = Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE,
+ CROP_TO_MASK = Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK,
+
+ /**
+ * @brief The policy to determine when an image should no longer be cached.
+ * @details Name "releasePolicy", Type ReleasePolicy::Type (Property::INTEGER) or Property::STRING
+ * @note Default ReleasePolicy::DESTROYED
+ * @see ReleasePolicy::Type
+ */
+ RELEASE_POLICY = CROP_TO_MASK + 2,
+};
+
+} //namespace Property
+
+} // namespace DevelImageVisual
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_DEVEL_API_VISUALS_IMAGE_VISUAL_PROPERTIES_DEVEL_H
#define __DALI_TOOLKIT_BUILDER_DECLARATIONS_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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 INCLUDES
+#include <dali/public-api/common/extents.h>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
typedef OptionalValue<Dali::Matrix> OptionalMatrix;
typedef OptionalValue<Dali::Matrix3> OptionalMatrix3;
typedef OptionalValue<Dali::Rect<int> > OptionalRect;
+typedef OptionalValue<Dali::Extents> OptionalExtents;
#endif // __DALI_TOOLKIT_BUILDER_DECLARATIONS_H__
return ret;
}
+inline OptionalExtents IsExtents(const OptionalChild& node)
+{
+ OptionalExtents extents;
+ if(node && (*node).Size())
+ {
+ if((*node).Size() >= 4)
+ {
+ TreeNode::ConstIterator iter((*node).CBegin());
+ int v[4];
+ if( CopyNumbers((*node).CBegin(), 4, v) )
+ {
+ extents = OptionalExtents(Dali::Extents(v[0], v[1], v[2], v[3]));
+ }
+ }
+ }
+ return extents;
+}
+
//
//
//
return IsRect( IsChild(&parent, childName) );
}
+inline OptionalExtents IsExtents(const TreeNode &parent, const std::string& childName)
+{
+ return IsExtents( IsChild(&parent, childName) );
+}
+
//
//
//
return IsRect( OptionalChild( node ) );
}
+inline OptionalExtents IsExtents(const TreeNode &node )
+{
+ return IsExtents( OptionalChild( node ) );
+}
+
//
//
//
{
return DeterminePropertyFromNode( *childValue, Dali::Property::ARRAY, value, replacement);
}
+ else if(*childType == "extents")
+ {
+ return DeterminePropertyFromNode( *childValue, Dali::Property::EXTENTS, value, replacement);
+ }
}
// else we failed to disambiguate
}
break;
}
+ case Property::EXTENTS:
+ {
+ if( OptionalExtents v = replacer.IsExtents(node) )
+ {
+ value = *v;
+ done = true;
+ }
+ break;
+ }
case Property::NONE:
{
break;
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
return ret;
}
-
+OptionalExtents Replacement::IsExtents( const TreeNode & node ) const
+{
+ OptionalExtents extents;
+ if( OptionalString replace = HasFullReplacement( node ) )
+ {
+ Property::Value value = GetFullReplacement( *replace );
+ if( Property::EXTENTS == value.GetType() )
+ {
+ extents = value.Get<Extents>();
+ }
+ }
+ else
+ {
+ extents = ::IsExtents( node );
+ }
+ return extents;
+}
OptionalFloat Replacement::IsFloat( OptionalChild child ) const
{
return ret;
}
+OptionalExtents Replacement::IsExtents( OptionalChild child ) const
+{
+ if( child )
+ {
+ return IsExtents( *child );
+ }
+ else
+ {
+ return OptionalExtents();
+ }
+}
+
} // namespace Internal
} // namespace Toolkit
#define __DALI_TOOLKIT_INTERNAL_BUILDER_REPLACEMENT__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
/* @brief Check node for a type
*
+ * @param node The TreeNode to check
+ * @return Optional value
+ */
+ OptionalExtents IsExtents( const TreeNode & node ) const;
+
+ /* @brief Check node for a type
+ *
* @param child The optional child TreeNode
* @return Optional value
*/
*/
bool IsArray( OptionalChild child, Property::Value& out ) const;
+ /* @brief Check node for a type
+ *
+ * @param child The optional child TreeNode
+ * @return Optional value
+ */
+ OptionalExtents IsExtents( OptionalChild child ) const;
+
private:
// Overriding map (overrides the default map). The map is not owned.
const Property::Map* const mOverrideMap;
const PropertyRegistration Control::Impl::PROPERTY_3( typeRegistration, "backgroundImage", Toolkit::Control::Property::BACKGROUND_IMAGE, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_4( typeRegistration, "keyInputFocus", Toolkit::Control::Property::KEY_INPUT_FOCUS, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_5( typeRegistration, "background", Toolkit::Control::Property::BACKGROUND, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_6( typeRegistration, "tooltip", Toolkit::DevelControl::Property::TOOLTIP, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_7( typeRegistration, "state", Toolkit::DevelControl::Property::STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_8( typeRegistration, "subState", Toolkit::DevelControl::Property::SUB_STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_9( typeRegistration, "leftFocusableActorId", Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_10( typeRegistration, "rightFocusableActorId", Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID,Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_11( typeRegistration, "upFocusableActorId", Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_12( typeRegistration, "downFocusableActorId", Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-
+const PropertyRegistration Control::Impl::PROPERTY_6( typeRegistration, "margin", Toolkit::Control::Property::MARGIN, Property::EXTENTS, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_7( typeRegistration, "padding", Toolkit::Control::Property::PADDING, Property::EXTENTS, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_8( typeRegistration, "tooltip", Toolkit::DevelControl::Property::TOOLTIP, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_9( typeRegistration, "state", Toolkit::DevelControl::Property::STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_10( typeRegistration, "subState", Toolkit::DevelControl::Property::SUB_STATE, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_11( typeRegistration, "leftFocusableActorId", Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_12( typeRegistration, "rightFocusableActorId", Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID,Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_13( typeRegistration, "upFocusableActorId", Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_14( typeRegistration, "downFocusableActorId", Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
Control::Impl::Impl( Control& controlImpl )
mStyleName(""),
mBackgroundColor(Color::TRANSPARENT),
mStartingPinchScale( NULL ),
+ mMargin( 0, 0, 0, 0 ),
+ mPadding( 0, 0, 0, 0 ),
mKeyEventSignal(),
mPinchGestureDetector(),
mPanGestureDetector(),
break;
}
+ case Toolkit::Control::Property::MARGIN:
+ {
+ Extents margin;
+ if( value.Get( margin ) )
+ {
+ controlImpl.mImpl->SetMargin( margin );
+ }
+ break;
+ }
+
+ case Toolkit::Control::Property::PADDING:
+ {
+ Extents padding;
+ if( value.Get( padding ) )
+ {
+ controlImpl.mImpl->SetPadding( padding );
+ }
+ break;
+ }
+
case Toolkit::DevelControl::Property::TOOLTIP:
{
TooltipPtr& tooltipPtr = controlImpl.mImpl->mTooltip;
tooltipPtr = Tooltip::New( control );
}
tooltipPtr->SetProperties( value );
+ break;
}
+
}
}
}
break;
}
+ case Toolkit::Control::Property::MARGIN:
+ {
+ value = controlImpl.mImpl->GetMargin();
+ break;
+ }
+
+ case Toolkit::Control::Property::PADDING:
+ {
+ value = controlImpl.mImpl->GetPadding();
+ break;
+ }
+
case Toolkit::DevelControl::Property::TOOLTIP:
{
Property::Map map;
value = map;
break;
}
-
}
}
mRemoveVisuals.Clear();
}
+void Control::Impl::SetMargin( Extents margin )
+{
+ mControlImpl.mImpl->mMargin = margin;
+}
+
+Extents Control::Impl::GetMargin() const
+{
+ return mControlImpl.mImpl->mMargin;
+}
+
+void Control::Impl::SetPadding( Extents padding )
+{
+ mControlImpl.mImpl->mPadding = padding;
+}
+
+Extents Control::Impl::GetPadding() const
+{
+ return mControlImpl.mImpl->mPadding;
+}
+
} // namespace Internal
} // namespace Toolkit
*/
void OnStageDisconnection();
+ /**
+ * @brief Sets the margin.
+ * @param[in] margin Margin is a collections of extent ( start, end, top, bottom )
+ */
+ void SetMargin( Extents margin );
+
+ /**
+ * @brief Returns the value of margin
+ * @return The value of margin
+ */
+ Extents GetMargin() const;
+
+ /**
+ * @brief Sets the padding.
+ * @param[in] padding Padding is a collections of extent ( start, end, top, bottom ).
+ */
+ void SetPadding( Extents padding );
+
+ /**
+ * @brief Returns the value of padding
+ * @return The value of padding
+ */
+ Extents GetPadding() const;
+
private:
/**
std::string mStyleName;
Vector4 mBackgroundColor; ///< The color of the background visual
Vector3* mStartingPinchScale; ///< The scale when a pinch gesture starts, TODO: consider removing this
+ Extents mMargin; ///< The margin values
+ Extents mPadding; ///< The padding values
Toolkit::Control::KeyEventSignalType mKeyEventSignal;
Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusGainedSignal;
Toolkit::Control::KeyInputFocusSignalType mKeyInputFocusLostSignal;
static const PropertyRegistration PROPERTY_10;
static const PropertyRegistration PROPERTY_11;
static const PropertyRegistration PROPERTY_12;
+ static const PropertyRegistration PROPERTY_13;
+ static const PropertyRegistration PROPERTY_14;
};
{
Vector2 rendererNaturalSize;
mVisual.GetNaturalSize( rendererNaturalSize );
+
+ Extents padding;
+ padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
+
+ rendererNaturalSize.width += ( padding.start + padding.end );
+ rendererNaturalSize.height += ( padding.top + padding.bottom );
return Vector3( rendererNaturalSize );
}
float ImageView::GetHeightForWidth( float width )
{
+ Extents padding;
+ padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
+
if( mVisual )
{
- return mVisual.GetHeightForWidth( width );
+ return mVisual.GetHeightForWidth( width ) + padding.top + padding.bottom;
}
else
{
- return Control::GetHeightForWidth( width );
+ return Control::GetHeightForWidth( width ) + padding.top + padding.bottom;
}
}
float ImageView::GetWidthForHeight( float height )
{
+ Extents padding;
+ padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
+
if( mVisual )
{
- return mVisual.GetWidthForHeight( height );
+ return mVisual.GetWidthForHeight( height ) + padding.start + padding.end;
}
else
{
- return Control::GetWidthForHeight( height );
+ return Control::GetWidthForHeight( height ) + padding.start + padding.end;
}
}
if( mVisual )
{
- // Pass in an empty map which uses default transform values meaning our visual fills the control
+ Extents margin;
+ margin = Self().GetProperty<Extents>( Toolkit::Control::Property::MARGIN );
+
+ Extents padding;
+ padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
+
+ Property::Map transformMap = Property::Map();
+
+ if( ( padding.start != 0 ) || ( padding.end != 0 ) || ( padding.top != 0 ) || ( padding.bottom != 0 ) ||
+ ( margin.start != 0 ) || ( margin.end != 0 ) || ( margin.top != 0 ) || ( margin.bottom != 0 ) )
+ {
+ transformMap.Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2( margin.start + padding.start, margin.top + padding.top ) )
+ .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
+ .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
+ .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
+ }
+
// Should provide a transform that handles aspect ratio according to image size
- mVisual.SetTransformAndSize( Property::Map(), size );
+ mVisual.SetTransformAndSize( transformMap, size );
}
}
// EXTERNAL INCLUDES
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/devel-api/object/property-helper-devel.h>
+#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
Vector2 textureSize = textNaturalSize + Vector2(wrapGap, 0.0f); // Add the gap as a part of the texture
// Create a texture of the text for scrolling
+ Size verifiedSize = textureSize;
+ const int maxTextureSize = Dali::GetMaxTextureSize();
+
+ //if the texture size width exceed maxTextureSize, modify the visual model size and enabled the ellipsis
+ if( verifiedSize.width > maxTextureSize )
+ {
+ verifiedSize.width = maxTextureSize;
+ if( textNaturalSize.width > maxTextureSize )
+ {
+ mController->SetTextElideEnabled( true );
+ }
+ GetHeightForWidth( maxTextureSize );
+ wrapGap = std::max( maxTextureSize - textNaturalSize.width, 0.0f );
+ }
+
Text::TypesetterPtr typesetter = Text::Typesetter::New( mController->GetTextModel() );
- PixelData data = typesetter->Render( textureSize, Text::Typesetter::RENDER_TEXT_AND_STYLES, true, Pixel::RGBA8888 ); // ignore the horizontal alignment
+
+ PixelData data = typesetter->Render( verifiedSize, Text::Typesetter::RENDER_TEXT_AND_STYLES, true, Pixel::RGBA8888 ); // ignore the horizontal alignment
Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D,
data.GetPixelFormat(),
data.GetWidth(),
// Set parameters for scrolling
Renderer renderer = static_cast<Internal::Visual::Base&>( GetImplementation( mVisual ) ).GetRenderer();
- mTextScroller->SetParameters( Self(), renderer, textureSet, controlSize, textureSize, wrapGap, direction, mController->GetHorizontalAlignment(), mController->GetVerticalAlignment() );
+ mTextScroller->SetParameters( Self(), renderer, textureSet, controlSize, verifiedSize, wrapGap, direction, mController->GetHorizontalAlignment(), mController->GetVerticalAlignment() );
}
void TextLabel::ScrollingFinished()
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "looping", BOOLEAN, LOOPING )
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "muted", BOOLEAN, MUTED )
DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "volume", MAP, VOLUME )
+DALI_PROPERTY_REGISTRATION( Toolkit, VideoView, "underlay", BOOLEAN, UNDERLAY )
DALI_SIGNAL_REGISTRATION( Toolkit, VideoView, "finished", FINISHED_SIGNAL )
const char* const VOLUME_LEFT( "volumeLeft" );
const char* const VOLUME_RIGHT( "volumeRight" );
+
+// 3.0 TC uses RENDERING_TARGET. It should be removed in next release
const char* const RENDERING_TARGET( "renderingTarget" );
const char* const WINDOW_SURFACE_TARGET( "windowSurfaceTarget" );
const char* const NATIVE_IMAGE_TARGET( "nativeImageTarget" );
mUpdateTriggerPropertyIndex( Property::INVALID_INDEX),
mNotification( NULL ),
mCurrentVideoPlayPosition( 0 ),
- mIsNativeImageTarget( true ),
mIsPlay( false ),
- mIsPause( false )
+ mIsPause( false ),
+ mIsUnderlay( true )
{
mVideoPlayer = Dali::VideoPlayer::New();
void VideoView::OnInitialize()
{
- Any source;
- Dali::NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New( source );
- mNativeImage = Dali::NativeImage::New( *nativeImageSourcePtr );
-
- mVideoPlayer.SetRenderingTarget( nativeImageSourcePtr );
- mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
-
mUpdateTriggerPropertyIndex = Self().RegisterProperty( "updateTrigger", true );
+ mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
+ SetWindowSurfaceTarget();
}
void VideoView::SetUrl( const std::string& url )
mPropertyMap.Clear();
}
- if( mIsNativeImageTarget )
+ if( !mIsUnderlay )
{
Actor self( Self() );
Internal::InitializeVisual( self, mVisual, mNativeImage );
if( target && target->Get( targetType ) && targetType == WINDOW_SURFACE_TARGET )
{
- this->SetWindowSurfaceTarget();
+ mIsUnderlay = true;
+ SetWindowSurfaceTarget();
}
else if( target && target->Get( targetType ) && targetType == NATIVE_IMAGE_TARGET )
{
- this->SetNativeImageTarget();
+ mIsUnderlay = false;
+ SetNativeImageTarget();
}
RelayoutRequest();
}
break;
}
+ case Toolkit::VideoView::Property::UNDERLAY:
+ {
+ bool underlay;
+ if( value.Get( underlay ) )
+ {
+ impl.SetUnderlay( underlay );
+ }
+ break;
+ }
}
}
}
value = map;
break;
}
+ case Toolkit::VideoView::Property::UNDERLAY:
+ {
+ value = impl.IsUnderlay();
+ break;
+ }
}
}
mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
mVideoPlayer.SetUrl( mUrl );
- mIsNativeImageTarget = false;
+ if( !mRenderer )
+ {
+ // For underlay rendering mode, video display area have to be transparent.
+ Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
+ Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+ mRenderer = Renderer::New( geometry, shader );
+
+ mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+ mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE );
+ mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ZERO );
+ mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE );
+ mRenderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ZERO );
+ }
+ self.AddRenderer( mRenderer );
+
+ UpdateDisplayArea();
if( mIsPlay )
{
{
mVideoPlayer.SetPlayPosition( curPos );
}
-
- // For underlay rendering mode, video display area have to be transparent.
- Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
- Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- Renderer renderer = Renderer::New( geometry, shader );
-
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ZERO );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ZERO );
- self.AddRenderer( renderer );
}
void VideoView::SetNativeImageTarget()
{
+ if( mVideoPlayer.IsVideoTextureSupported() == false )
+ {
+ DALI_LOG_ERROR( "Platform doesn't support decoded video frame images\n" );
+ mIsUnderlay = true;
+ return;
+ }
+
Actor self( Self() );
int curPos = mVideoPlayer.GetPlayPosition();
mVideoPlayer.SetUrl( mUrl );
Internal::InitializeVisual( self, mVisual, mNativeImage );
- mIsNativeImageTarget = true;
+ Self().RemoveRenderer( mRenderer );
if( mIsPlay )
{
void VideoView::UpdateDisplayArea()
{
+ if( !mIsUnderlay )
+ {
+ return;
+ }
+
Actor self( Self() );
bool positionUsesAnchorPoint = self.GetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT ).Get< bool >();
mVideoPlayer.SetDisplayArea( mDisplayArea );
}
+void VideoView::SetUnderlay( bool set )
+{
+ if( set != mIsUnderlay )
+ {
+ mIsUnderlay = set;
+
+ if( mIsUnderlay )
+ {
+ SetWindowSurfaceTarget();
+ }
+ else
+ {
+ SetNativeImageTarget();
+ }
+ }
+}
+
+bool VideoView::IsUnderlay()
+{
+ return mIsUnderlay;
+}
+
} // namespace Internal
} // namespace toolkit
*/
static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
- /*
+ /**
* @brief Updates video display area for window rendering target
*/
void UpdateDisplayArea();
+ /**
+ * @brief Sets underlay flag and initializes new rendering target by flag.
+ */
+ void SetUnderlay( bool set );
+
+ /**
+ * @brief Checks underlay flag.
+ */
+ bool IsUnderlay();
+
private: // From Control
/**
Dali::Toolkit::VideoView::VideoViewSignalType mFinishedSignal;
std::string mUrl;
Dali::DisplayArea mDisplayArea;
+ Dali::Renderer mRenderer;
Property::Index mUpdateTriggerPropertyIndex;
TriggerEventInterface* mNotification;
int mCurrentVideoPlayPosition;
- bool mIsNativeImageTarget;
bool mIsPlay;
bool mIsPause;
+ bool mIsUnderlay;
};
} // namespace Internal
for( unsigned int y = underlineYOffset; y < underlineYOffset + maxUnderlineThickness; y++ )
{
- if( ( y < 0 ) || ( y > bufferHeight - 1 ) )
+ if( y > bufferHeight - 1 )
{
// Do not write out of bounds.
break;
for( unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++ )
{
- if( ( x < 0 ) || ( x > bufferWidth - 1 ) )
+ if( x > bufferWidth - 1 )
{
// Do not write out of bounds.
break;
mPlaceholderFont( NULL ),
mPlaceholderTextActive(),
mPlaceholderTextInactive(),
- mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ),
+ mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ), // This color has been published in the Public API (placeholder-properties.h).
mEventQueue(),
mInputStyleChangedQueue(),
mPreviousState( INACTIVE ),
#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/text-controls/placeholder-properties.h>
#include <dali-toolkit/internal/text/bidirectional-support.h>
#include <dali-toolkit/internal/text/character-set-conversion.h>
#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
const std::string EMPTY_STRING("");
-const char * const PLACEHOLDER_TEXT = "placeholderText";
-const char * const PLACEHOLDER_TEXT_FOCUSED = "placeholderTextFocused";
-const char * const PLACEHOLDER_COLOR = "placeholderColor";
-const char * const PLACEHOLDER_FONT_FAMILY = "placeholderFontFamily";
-const char * const PLACEHOLDER_FONT_STYLE = "placeholderFontStyle";
-const char * const PLACEHOLDER_POINT_SIZE = "placeholderPointSize";
-const char * const PLACEHOLDER_PIXEL_SIZE = "placeholderPixelSize";
-const char * const PLACEHOLDER_ELLIPSIS = "placeholderEllipsis";
+const char * const PLACEHOLDER_TEXT = "text";
+const char * const PLACEHOLDER_TEXT_FOCUSED = "textFocused";
+const char * const PLACEHOLDER_COLOR = "color";
+const char * const PLACEHOLDER_FONT_FAMILY = "fontFamily";
+const char * const PLACEHOLDER_FONT_STYLE = "fontStyle";
+const char * const PLACEHOLDER_POINT_SIZE = "pointSize";
+const char * const PLACEHOLDER_PIXEL_SIZE = "pixelSize";
+const char * const PLACEHOLDER_ELLIPSIS = "ellipsis";
float ConvertToEven( float value )
{
Property::Key& key = keyValue.first;
Property::Value& value = keyValue.second;
- if( key == PLACEHOLDER_TEXT )
+ if( key == Toolkit::Text::PlaceHolder::Property::TEXT || key == PLACEHOLDER_TEXT )
{
std::string text = "";
value.Get( text );
SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text );
}
- else if( key == PLACEHOLDER_TEXT_FOCUSED )
+ else if( key == Toolkit::Text::PlaceHolder::Property::TEXT_FOCUSED || key == PLACEHOLDER_TEXT_FOCUSED )
{
std::string text = "";
value.Get( text );
SetPlaceholderText( Controller::PLACEHOLDER_TYPE_ACTIVE, text );
}
- else if( key == PLACEHOLDER_COLOR )
+ else if( key == Toolkit::Text::PlaceHolder::Property::COLOR || key == PLACEHOLDER_COLOR )
{
Vector4 textColor;
value.Get( textColor );
SetPlaceholderTextColor( textColor );
}
}
- else if( key == PLACEHOLDER_FONT_FAMILY )
+ else if( key == Toolkit::Text::PlaceHolder::Property::FONT_FAMILY || key == PLACEHOLDER_FONT_FAMILY )
{
std::string fontFamily = "";
value.Get( fontFamily );
SetPlaceholderFontFamily( fontFamily );
}
- else if( key == PLACEHOLDER_FONT_STYLE )
+ else if( key == Toolkit::Text::PlaceHolder::Property::FONT_STYLE || key == PLACEHOLDER_FONT_STYLE )
{
SetFontStyleProperty( this, value, Text::FontStyle::PLACEHOLDER );
}
- else if( key == PLACEHOLDER_POINT_SIZE )
+ else if( key == Toolkit::Text::PlaceHolder::Property::POINT_SIZE || key == PLACEHOLDER_POINT_SIZE )
{
float pointSize;
value.Get( pointSize );
SetPlaceholderTextFontSize( pointSize, Text::Controller::POINT_SIZE );
}
}
- else if( key == PLACEHOLDER_PIXEL_SIZE )
+ else if( key == Toolkit::Text::PlaceHolder::Property::PIXEL_SIZE || key == PLACEHOLDER_PIXEL_SIZE )
{
float pixelSize;
value.Get( pixelSize );
SetPlaceholderTextFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
}
}
- else if( key == PLACEHOLDER_ELLIPSIS )
+ else if( key == Toolkit::Text::PlaceHolder::Property::ELLIPSIS || key == PLACEHOLDER_ELLIPSIS )
{
bool ellipsis;
value.Get( ellipsis );
{
if( !mImpl->mEventData->mPlaceholderTextActive.empty() )
{
- map[ PLACEHOLDER_TEXT_FOCUSED ] = mImpl->mEventData->mPlaceholderTextActive;
+ map[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = mImpl->mEventData->mPlaceholderTextActive;
}
if( !mImpl->mEventData->mPlaceholderTextInactive.empty() )
{
- map[ PLACEHOLDER_TEXT ] = mImpl->mEventData->mPlaceholderTextInactive;
+ map[ Text::PlaceHolder::Property::TEXT ] = mImpl->mEventData->mPlaceholderTextInactive;
}
- map[ PLACEHOLDER_COLOR ] = mImpl->mEventData->mPlaceholderTextColor;
- map[ PLACEHOLDER_FONT_FAMILY ] = GetPlaceholderFontFamily();
+ map[ Text::PlaceHolder::Property::COLOR ] = mImpl->mEventData->mPlaceholderTextColor;
+ map[ Text::PlaceHolder::Property::FONT_FAMILY ] = GetPlaceholderFontFamily();
Property::Value fontStyleMapGet;
GetFontStyleProperty( this, fontStyleMapGet, Text::FontStyle::PLACEHOLDER );
- map[ PLACEHOLDER_FONT_STYLE ] = fontStyleMapGet;
+ map[ Text::PlaceHolder::Property::FONT_STYLE ] = fontStyleMapGet;
// Choose font size : POINT_SIZE or PIXEL_SIZE
if( !mImpl->mEventData->mIsPlaceholderPixelSize )
{
- map[ PLACEHOLDER_POINT_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE );
+ map[ Text::PlaceHolder::Property::POINT_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE );
}
else
{
- map[ PLACEHOLDER_PIXEL_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE );
+ map[ Text::PlaceHolder::Property::PIXEL_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE );
}
if( mImpl->mEventData->mPlaceholderEllipsisFlag )
{
- map[ PLACEHOLDER_ELLIPSIS ] = IsPlaceholderTextElideEnabled();
+ map[ Text::PlaceHolder::Property::ELLIPSIS ] = IsPlaceholderTextElideEnabled();
}
}
}
\n
void main()\n
{\n
+ if ( vTexCoord.y > 1.0 )\n
+ discard;\n
gl_FragColor = texture2D( sTexture, vTexCoord );\n
}\n
);
DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
+// release policies
+DALI_ENUM_TO_STRING_TABLE_BEGIN( RELEASE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DETACHED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DESTROYED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, NEVER )
+DALI_ENUM_TO_STRING_TABLE_END( RELEASE_POLICY )
+
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
mSamplingMode( samplingMode ),
mWrapModeU( WrapMode::DEFAULT ),
mWrapModeV( WrapMode::DEFAULT ),
+ mReleasePolicy( DevelImageVisual::ReleasePolicy::DETACHED ),
mAttemptAtlasing( false ),
- mLoadingStatus( false )
+ mLoading( false )
{
}
mSamplingMode( SamplingMode::DEFAULT ),
mWrapModeU( WrapMode::DEFAULT ),
mWrapModeV( WrapMode::DEFAULT ),
+ mReleasePolicy( DevelImageVisual::ReleasePolicy::DESTROYED ),
mAttemptAtlasing( false ),
- mLoadingStatus( false )
+ mLoading( false )
{
}
ImageVisual::~ImageVisual()
{
- if( mMaskingData && Stage::IsInstalled() )
+ if( Stage::IsInstalled() )
{
- // TextureManager could have been deleted before the actor that contains this
- // ImageVisual is destroyed (e.g. due to stage shutdown). Ensure the stage
- // is still valid before accessing texture manager.
- if( mMaskingData->mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID )
+ if( mMaskingData )
+ {
+ // TextureManager could have been deleted before the actor that contains this
+ // ImageVisual is destroyed (e.g. due to stage shutdown). Ensure the stage
+ // is still valid before accessing texture manager.
+ if( mMaskingData->mAlphaMaskId != TextureManager::INVALID_TEXTURE_ID )
+ {
+ TextureManager& textureManager = mFactoryCache.GetTextureManager();
+ textureManager.Remove( mMaskingData->mAlphaMaskId );
+ }
+ }
+
+ // ImageVisual destroyed so remove texture unless ReleasePolicy is set to never release
+ if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID ) && ( mReleasePolicy != DevelImageVisual::ReleasePolicy::NEVER ) )
{
- TextureManager& textureManager = mFactoryCache.GetTextureManager();
- textureManager.Remove( mMaskingData->mAlphaMaskId );
+ RemoveTexture();
}
}
}
{
DoSetProperty( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second );
}
- else if ( keyValue.first == IMAGE_ATLASING )
+ else if( keyValue.first == IMAGE_ATLASING )
{
DoSetProperty( Toolkit::ImageVisual::Property::ATLASING, keyValue.second );
}
- else if ( keyValue.first == ALPHA_MASK_URL )
+ else if( keyValue.first == ALPHA_MASK_URL )
{
DoSetProperty( Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second );
}
- else if ( keyValue.first == MASK_CONTENT_SCALE_NAME )
+ else if( keyValue.first == MASK_CONTENT_SCALE_NAME )
{
DoSetProperty( Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second );
}
- else if ( keyValue.first == CROP_TO_MASK_NAME )
+ else if( keyValue.first == CROP_TO_MASK_NAME )
{
DoSetProperty( Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second );
}
+ else if( keyValue.first == RELEASE_POLICY_NAME )
+ {
+ DoSetProperty( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, keyValue.second );
+ }
}
}
}
}
break;
}
+
+ case Toolkit::DevelImageVisual::Property::RELEASE_POLICY:
+ {
+ int releasePolicy;
+ Scripting::GetEnumerationProperty( value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy );
+ mReleasePolicy = DevelImageVisual::ReleasePolicy::Type( releasePolicy );
+ break;
+ }
}
}
TextureSet textures =
textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
mMaskingData, IsSynchronousResourceLoading(), mTextureId,
- atlasRect, attemptAtlasing, mLoadingStatus, mWrapModeU,
+ atlasRect, attemptAtlasing, mLoading, mWrapModeU,
mWrapModeV, this, this, mFactoryCache.GetAtlasManager());
if(attemptAtlasing)
{
TextureSet textures =
textureManager.LoadTexture(mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
mMaskingData, IsSynchronousResourceLoading(), mTextureId,
- atlasRect, attemptAtlasing, mLoadingStatus, mWrapModeU, mWrapModeV, this,
+ atlasRect, attemptAtlasing, mLoading, mWrapModeU, mWrapModeV, this,
nullptr, nullptr); // no atlasing
DALI_ASSERT_DEBUG(attemptAtlasing == false);
CreateRenderer( textures );
{
InitializeRenderer();
}
- else if ( mImage )
+ else if( mImage )
{
InitializeRenderer( mImage );
}
- if ( !mImpl->mRenderer )
+ if( !mImpl->mRenderer )
{
return;
}
mPlacementActor = actor;
// Search the Actor tree to find if Layer UI behaviour set.
Layer layer = actor.GetLayer();
- if ( layer && layer.GetBehavior() == Layer::LAYER_3D )
+ if( layer && layer.GetBehavior() == Layer::LAYER_3D )
{
// Layer 3D set, do not align pixels
mImpl->mRenderer.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
}
- if( mLoadingStatus == false )
+ if( mLoading == false )
{
actor.AddRenderer( mImpl->mRenderer );
mPlacementActor.Reset();
{
// Visual::Base::SetOffStage only calls DoSetOffStage if mRenderer exists (is on onstage)
- //If we own the image then make sure we release it when we go off stage
+ // Image release is dependent on the ReleasePolicy, renderer is destroyed.
actor.RemoveRenderer( mImpl->mRenderer);
+ if( mReleasePolicy == DevelImageVisual::ReleasePolicy::DETACHED )
+ {
+ RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
+ }
+
if( mImageUrl.IsValid() )
{
- RemoveTexture( mImageUrl.GetUrl() );
+ // Legacy support for deprecated Dali::Image
mImage.Reset();
}
- mLoadingStatus = false;
+ mLoading = false;
mImpl->mRenderer.Reset();
mPlacementActor.Reset();
}
map.Insert( Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, mMaskingData->mContentScaleFactor );
map.Insert( Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask );
}
+
+ map.Insert( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, mReleasePolicy );
+
}
void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
// reset the weak handle so that the renderer only get added to actor once
mPlacementActor.Reset();
}
- mLoadingStatus = false;
+ mLoading = false;
}
// From Texture Manager
ResourceReady();
}
}
- mLoadingStatus = false;
+ mLoading = false;
}
-void ImageVisual::RemoveTexture(const std::string& url)
+void ImageVisual::RemoveTexture()
{
if( mTextureId != TextureManager::INVALID_TEXTURE_ID )
{
#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>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
namespace Dali
{
* | pixelArea | VECTOR4 |
* | wrapModeU | INTEGER OR STRING |
* | wrapModeV | INTEGER OR STRING |
+ * | releasePolicy | INTEGER OR STRING |
*
* where pixelArea is a rectangular area.
* In its Vector4 value, the first two elements indicate the top-left position of the area,
* "DEFAULT"
*
*
+ * where releasePolicy should be one of the following policies for when to cache the image
+ * "DETACHED" // Release image from cache when visual detached from stage
+ * "DESTROYED" // Keep image in cache until the visual is destroyed
+ * "NEVER" // Keep image in cache until application ends.
+ *
* If the Visual is in a LayerUI it will pixel align the image, using a Layer3D will disable pixel alignment.
* Changing layer behaviour between LayerUI to Layer3D whilst the visual is already staged will not have an effect.
*/
void SetTextureRectUniform( const Vector4& textureRect );
/**
- * Remove the texture if it is not used anymore.
+ * Remove texture with valid TextureId
*/
- void RemoveTexture(const std::string& url);
+ void RemoveTexture();
/**
* Helper method to set individual values by index key.
Dali::SamplingMode::Type mSamplingMode:4;
Dali::WrapMode::Type mWrapModeU:3;
Dali::WrapMode::Type mWrapModeV:3;
+ DevelImageVisual::ReleasePolicy::Type mReleasePolicy;
bool mAttemptAtlasing; ///< If true will attempt atlasing, otherwise create unique texture
- bool mLoadingStatus; ///< True if the texture is being loaded asynchronously, or false when it has loaded.
+ bool mLoading; ///< True if the texture is still loading.
};
// Set the color of non-transparent pixel in text to what it is animated to.
// Markup text with multiple text colors are not animated (but can be supported later on if required).
// Emoji color are not animated.
- mediump vec4 textColor = textTexture * textTexture.a;\n
- mediump float vstep = step( 0.0001, textColor.a );\n
- textColor.rgb = mix( textColor.rgb, uTextColorAnimatable.rgb, vstep * maskTexture );\n
+ mediump float vstep = step( 0.0001, textTexture.a );\n
+ textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture );\n
// Draw the text as overlay above the style
- gl_FragColor = textColor * uColor * vec4( mixColor, opacity );\n
+ gl_FragColor = textTexture * uColor * vec4( mixColor, opacity );\n
}\n
);
// Set the color of non-transparent pixel in text to what it is animated to.
// Markup text with multiple text colors are not animated (but can be supported later on if required).
// Emoji color are not animated.
- mediump vec4 textColor = textTexture * textTexture.a;\n
- mediump float vstep = step( 0.0001, textColor.a );\n
- textColor.rgb = mix( textColor.rgb, uTextColorAnimatable.rgb, vstep * maskTexture * ( 1.0 - uHasMultipleTextColors ) );\n
+ mediump float vstep = step( 0.0001, textTexture.a );\n
+ textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture * ( 1.0 - uHasMultipleTextColors ) );\n
// Draw the text as overlay above the style
- gl_FragColor = ( textColor + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, opacity );\n
+ gl_FragColor = ( textTexture + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, opacity );\n
}\n
);
const char * const FRAME_DELAY_NAME("frameDelay");
const char * const MASK_CONTENT_SCALE_NAME("maskContentScale");
const char * const CROP_TO_MASK_NAME("cropToMask");
+const char * const RELEASE_POLICY_NAME("releasePolicy");
// Text visual
const char * const TEXT_PROPERTY( "text" );
extern const char * const FRAME_DELAY_NAME;
extern const char * const MASK_CONTENT_SCALE_NAME;
extern const char * const CROP_TO_MASK_NAME;
+extern const char * const RELEASE_POLICY_NAME;
// Text visual
extern const char * const TEXT_PROPERTY;
}
}
+/**
+ * @brief Sets Control::Property::BACKGROUND visual
+ * @param[in] controlImpl The control implementation
+ * @param[in] visual The control background visual
+ * @param[in] size The current size
+ */
+void SetBackgroundVisual( Control::Impl& controlImpl, Toolkit::Visual::Base& visual, const Vector2& size )
+{
+ Property::Map transformMap = Property::Map();
+
+ Vector2 newSize( 0.f, 0.f );
+ newSize.width = size.width + ( controlImpl.mPadding.start + controlImpl.mPadding.end );
+ newSize.height = size.height + ( controlImpl.mPadding.top + controlImpl.mPadding.bottom );
+
+ if( ( controlImpl.mMargin.start != 0 ) ||
+ ( controlImpl.mMargin.end != 0 ) ||
+ ( controlImpl.mMargin.top != 0 ) ||
+ ( controlImpl.mMargin.bottom != 0 ) )
+ {
+ transformMap.Add( Toolkit::Visual::Transform::Property::SIZE, newSize )
+ .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
+ .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2( controlImpl.mMargin.start, controlImpl.mMargin.top ) )
+ .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
+ .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
+ .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
+ }
+ else if( ( controlImpl.mPadding.start != 0 ) ||
+ ( controlImpl.mPadding.end != 0 ) ||
+ ( controlImpl.mPadding.top != 0 ) ||
+ ( controlImpl.mPadding.bottom != 0 ) )
+ {
+ transformMap.Add( Toolkit::Visual::Transform::Property::SIZE, newSize )
+ .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
+ .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
+ .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
+ }
+
+ visual.SetTransformAndSize( transformMap, newSize ); // Send an empty map as we do not want to modify the visual's set transform
+}
+
} // unnamed namespace
if( visual )
{
Vector2 size( targetSize );
- visual.SetTransformAndSize( Property::Map(), size ); // Send an empty map as we do not want to modify the visual's set transform
+ SetBackgroundVisual( *mImpl, visual, size );
+
}
}
{
for( unsigned int i = 0, numChildren = Self().GetChildCount(); i < numChildren; ++i )
{
- container.Add( Self().GetChildAt( i ), size );
+ Actor child = Self().GetChildAt( i );
+ Vector2 newChildSize( size );
+
+ // When set the padding or margin on the control, child should be resized and repositioned.
+ if( ( mImpl->mPadding.start != 0 ) || ( mImpl->mPadding.end != 0 ) || ( mImpl->mPadding.top != 0 ) || ( mImpl->mPadding.bottom != 0 ) ||
+ ( mImpl->mMargin.start != 0 ) || ( mImpl->mMargin.end != 0 ) || ( mImpl->mMargin.top != 0 ) || ( mImpl->mMargin.bottom != 0 ) )
+ {
+ newChildSize.width = size.width - ( mImpl->mPadding.start + mImpl->mPadding.end );
+ newChildSize.height = size.height - ( mImpl->mPadding.top + mImpl->mPadding.bottom );
+
+ Vector3 childPosition = child.GetTargetSize();
+ childPosition.x += ( mImpl->mMargin.start + mImpl->mPadding.start );
+ childPosition.y += ( mImpl->mMargin.top + mImpl->mPadding.top );
+
+ child.SetPosition( childPosition );
+ }
+
+ container.Add( child, newChildSize );
}
Toolkit::Visual::Base visual = mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
if( visual )
{
- visual.SetTransformAndSize( Property::Map(), size ); // Send an empty map as we do not want to modify the visual's set transform
+ SetBackgroundVisual( *mImpl, visual, size );
}
}
{
Vector2 naturalSize;
visual.GetNaturalSize( naturalSize );
+ naturalSize.width += ( mImpl->mPadding.start + mImpl->mPadding.end );
+ naturalSize.height += ( mImpl->mPadding.top + mImpl->mPadding.bottom );
return Vector3( naturalSize );
}
return Vector3::ZERO;
enum
{
/**
- * @brief name "styleName", type std::string.
+ * @brief The name of the style to be applied to the control.
+ * @details Name "styleName", type Property::STRING.
+ * @see Toolkit::Control::SetStyleName()
* @SINCE_1_0.0
- * @see SetStyleName
*/
STYLE_NAME = PROPERTY_START_INDEX,
+
/**
* @DEPRECATED_1_1.3
- * @brief name "backgroundColor", mutually exclusive with BACKGROUND_IMAGE & BACKGROUND, type Vector4.
+ * @brief The background color of the control.
+ *
+ * Mutually exclusive with BACKGROUND_IMAGE & BACKGROUND.
+ * @details Name "backgroundColor", type Property::VECTOR4.
+ * @see Toolkit::Control::SetStyleName()
* @SINCE_1_0.0
- * @see SetStyleName
*/
BACKGROUND_COLOR,
+
/**
* @DEPRECATED_1_1.3
- * @brief name "backgroundImage", mutually exclusive with BACKGROUND_COLOR & BACKGROUND, type Map.
+ * @brief The background image of the control.
+ *
+ * Mutually exclusive with BACKGROUND_COLOR & BACKGROUND.
+ * @details Name "backgroundImage", type Property::MAP.
* @SINCE_1_0.0
*/
BACKGROUND_IMAGE,
+
/**
- * @brief name "keyInputFocus", type bool.
+ * @brief Receives key events to the control.
+ * @details Name "keyInputFocus", type Property::BOOLEAN.
+ * @see Toolkit::Control::SetKeyInputFocus()
* @SINCE_1_0.0
- * @see SetKeyInputFocus
*/
KEY_INPUT_FOCUS,
+
/**
- * @brief name "background", mutually exclusive with BACKGROUND_COLOR & BACKGROUND_IMAGE, type Map or std::string for URL or Vector4 for Color.
+ * @brief The background of the control.
+ *
+ * Mutually exclusive with BACKGROUND_COLOR & BACKGROUND_IMAGE.
+ * @details Name "background", type Property::MAP or std::string for URL or Property::VECTOR4 for Color.
* @SINCE_1_1.3
*/
BACKGROUND,
+
+ /**
+ * @brief The outer space around the control.
+ * @details Name "margin", type Property::EXTENTS.
+ * @SINCE_1_2.62
+ */
+ MARGIN,
+
+ /**
+ * @brief The inner space of the control.
+ * @details Name "padding", type Property::EXTENTS.
+ * @SINCE_1_2.62
+ */
+ PADDING
};
};
/**
* @brief ProgressBar is a control to give the user an indication of the progress of an operation.
- * *
- * Determinate Progress State
*
- * # : Progress visual
- * * : Secondary Progress visual
- * = : Track visual
- * 40% : Label visual
- *
- * =============================================
- * = ###############**** 40% =
- * =============================================
- *
- * Indeterminate Progress State
- *
- * / : Indeterminate visual
- *
- * =============================================
- * = ///////////////////////////////////////// =
- * =============================================
- *
- * Also progress value percentage is shown as text inside the progress bar.
* Signals
* | %Signal Name | Method |
* |-------------------|-------------------------------|
--- /dev/null
+#ifndef DALI_TOOLKIT_PLACEHOLDER_PROPERTIES_H
+#define DALI_TOOLKIT_PLACEHOLDER_PROPERTIES_H
+
+/*
+ * Copyright (c) 2017 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+/**
+ * @addtogroup dali_toolkit_controls
+ * @{
+ */
+
+namespace Text
+{
+
+/**
+ * @brief Placeholder text used by Text controls to show text before any text inputed.
+ * @SINCE_1_2.62
+ *
+ */
+namespace PlaceHolder
+{
+
+/**
+ * @brief Placeholder text Propeties used by Text controls to show placeholder
+ * @SINCE_1_2.62
+ *
+ */
+namespace Property
+{
+
+/**
+ * @brief The configurable settings for the Placeholder text.
+ * @SINCE_1_2.62
+ *
+ */
+enum Setting
+{
+ /**
+ * @brief The text to display as a placeholder.
+ * @details Name "text", type Property::STRING.
+ * @note Optional. If not provided then no placeholder text will be shown whilst control not focused.
+ * @SINCE_1_2.62
+ */
+ TEXT,
+
+ /**
+ * @brief The text to display as placeholder when focused.
+ * @details Name "textFocused", type Property::STRING.
+ * @note Optional. If not provided then no placeholder text will be shown when focused.
+ * @SINCE_1_2.62
+ */
+ TEXT_FOCUSED,
+
+ /**
+ * @brief The colour of the placeholder text.
+ * @details Name "color", type Property::VECTOR4.
+ * @note If color not provided then 80% white will be used.
+ * @SINCE_1_2.62
+ */
+ COLOR,
+
+ /**
+ * @brief The font family to be used for placeholder text.
+ * @details Name "fontFamily", type Property::STRING.
+ * @note Optional. Default font family used if not provided.
+ * @SINCE_1_2.62
+ */
+ FONT_FAMILY,
+
+ /**
+ * @brief The font style to be used for placeholder text.
+ * @details Name "fontStyle", type Property::MAP.
+ *
+ * Example usage:
+ * @code
+ * Property::Map fontStylePropertyMap;
+ * fontStylePropertyMap.Insert( "weight", "bold" );
+ * fontStylePropertyMap.Insert( "width", "condensed" );
+ * fontStylePropertyMap.Insert( "slant", "italic" );
+ * ...
+ * placeholderPropertyMap[ Text::PlaceHolder::Property::FONT_STYLE] = fontStylePropertyMap;
+ * @endcode
+ *
+ * @note Optional. Default font style used if not provided.
+ * @SINCE_1_2.62
+ */
+ FONT_STYLE,
+
+ /**
+ * @brief The font point size to be used.
+ * @details Name "pointSize", type Property::FLOAT.
+ * @note Optional. Not required if PIXEL_SIZE provided. If neither provided then the text control point size is used.
+ * @SINCE_1_2.62
+ */
+ POINT_SIZE,
+
+ /**
+ * @brief The font size in pixels to be used
+ * @details Name "pixelSize", type Property::FLOAT.
+ * @note Optional. Not required if POINT_SIZE provided. If neither provided then the text control point size is used.
+ * @SINCE_1_2.62
+ */
+ PIXEL_SIZE,
+
+ /**
+ * @brief If ellipsis should be used when placeholder is too long.
+ * @details Name "ellipsis", type Property::BOOLEAN
+ * @note Optional. Default is false.
+ * @SINCE_1_2.62
+ */
+ ELLIPSIS
+};
+
+} // namespace Property
+
+} // namespace PlaceHolder
+
+
+} // namespace Text
+
+/**
+ * @}
+ */
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif //DALI_TOOLKIT_PLACEHOLDER_PROPERTIES_H
* Example Usage:
* @code
* Property::Map propertyMap;
- * propertyMap["placeholderText"] = "Setting Placeholder Text";
- * propertyMap["placeholderTextFocused"] = "Setting Placeholder Text Focused";
- * propertyMap["placeholderColor"] = Color::RED;
- * propertyMap["placeholderFontFamily"] = "Arial";
- * propertyMap["placeholderPointSize"] = 12.0f;
- * propertyMap["placeholderEllipsis"] = true;
+ * propertyMap[ Text::PlaceHolder::Property::TEXT ] = "Setting Placeholder Text";
+ * propertyMap[ Text::PlaceHolder::Property::TEXT_FOCUSED] = "Setting Placeholder Text Focused";
+ * propertyMap[ Text::PlaceHolder::Property::COLOR] = Color::RED;
+ * propertyMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = "Arial";
+ * propertyMap[ Text::PlaceHolder::Property::POINT_SIZE ] = 12.0f;
+ * propertyMap[ Text::PlaceHolder::Property::ELLIPSIS ] = true;
*
* Property::Map fontStyleMap;
* fontStyleMap.Insert( "weight", "bold" );
* fontStyleMap.Insert( "width", "condensed" );
* fontStyleMap.Insert( "slant", "italic" );
- * propertyMap["placeholderFontStyle"] = fontStyleMap;
+ * propertyMap[ Text::PlaceHolder::Property::FONT_STYLE] = fontStyleMap;
*
* field.SetProperty( TextField::Property::PLACEHOLDER, propertyMap );
* @endcode
* @details Name "autoScrollGap", type Property::INT.
* @SINCE_1_1.35
* @note Default in style sheet but can be overridden to prevent same text being shown at start and end.
+ * @note Displayed gap size is not guaranteed if the text length plus gap exceeds the maximum texture size (i.e. GL_MAX_TEXTURE_SIZE).
*/
AUTO_SCROLL_GAP,
// Signal
typedef Signal< void (VideoView&) > VideoViewSignalType; ///< Video playback finished signal type @ SINCE_1_1.38
+public:
+
/**
* @brief Enumeration for the start and end property ranges for this control.
* @SINCE_1_0.0
* @brief name "volume", left and right volume scalar as float type, Property::Map with two values ( "left" and "right" ).
* @SINCE_1_1.38
*/
- VOLUME
+ VOLUME,
+
+ /**
+ * @brief name "underlay", Video rendering by underlay, true or false
+ * This shows video composited underneath the window by the system. This means it may ignore rotation of the video-view
+ * If false, video-view shows decoded frame images sequentially.
+ * If Platform or video plugin doesn't support decoded frame images, this should always be true.
+ * @SINCE_1_2.62
+ */
+ UNDERLAY
};
};
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 2;
-const unsigned int TOOLKIT_MICRO_VERSION = 61;
+const unsigned int TOOLKIT_MICRO_VERSION = 62;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
public_api_text_controls_header_files = \
$(public_api_src_dir)/controls/text-controls/hidden-input-properties.h \
+ $(public_api_src_dir)/controls/text-controls/placeholder-properties.h \
$(public_api_src_dir)/controls/text-controls/text-editor.h \
$(public_api_src_dir)/controls/text-controls/text-label.h \
$(public_api_src_dir)/controls/text-controls/text-field.h
* @details Name "transform", type Property::MAP.
* @SINCE_1_2.60
* @note Optional.
- * @see DevelVisual::Transform::Property
+ * @see Toolkit::Visual::Transform::Property
*/
TRANSFORM,
* control.SetProperty( ..., // Some visual based property
* Property::Map().Add( ... ) // Properties to set up visual
* .Add( Visual::Property::TRANSFORM,
- * Property::Array().Add( DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( Policy::ABSOLUTE, Policy::RELATIVE ) ) )
- * .Add( DevelVisual::Transform::Property::OFFSET, Vector2( 10, 1.0f ) ) );
+ * Property::Array().Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Policy::ABSOLUTE, Policy::RELATIVE ) ) )
+ * .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2( 10, 1.0f ) ) );
* @endcode
*
* JSON:
* <td>Slider is a control to enable sliding an indicator between two values.</td>
* </tr>
* <tr>
+ * <td style="padding-left:1em">@ref dali_toolkit_controls_progress_bar</td>
+ * <td>ProgressBar is a control to give the user an indication of the progress of an operation.</td>
+ * </tr>
+ * <tr>
* <td>@ref dali_toolkit_managers</td>
* <td>Singleton classes for managing application-wide functionalities.</td>
* </tr>
* @defgroup dali_toolkit_controls_slider Slider
* @brief Slider is a control to enable sliding an indicator between two values.
+ * @defgroup dali_toolkit_controls_progress_bar Progress Bar
+ * @brief ProgressBar is a control to give the user an indication of the progress of an operation.
+
* @}
* @defgroup dali_toolkit_managers Managers
Name: dali-toolkit
Summary: Dali 3D engine Toolkit
-Version: 1.2.61
+Version: 1.2.62
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT