../dali-toolkit/dali-toolkit-test-utils/toolkit-singleton-service.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
../dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
../dali-toolkit/dali-toolkit-test-utils/dummy-control.cpp
../dali-toolkit/dali-toolkit-test-utils/mesh-builder.cpp
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <toolkit-text-utils.h>
+#include <toolkit-event-thread-callback.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/color/color-visual.h>
END_TEST;
}
+
+int UtcDaliAnimatedVectorImageVisualSetProperties(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliAnimatedVectorImageVisualSetProperties" );
+
+ Property::Map propertyMap;
+ propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( DevelImageVisual::Property::LOOP_COUNT, 3 )
+ .Add( DevelImageVisual::Property::PLAY_RANGE, Vector2( 0.2f, 0.8f ) );
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+ Toolkit::Internal::Visual::Base& visualImpl = GetImplementation( visual );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ actor.SetSize( 200.0f, 200.0f );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ // Wait for resource ready event callback
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ Property::Map propertyMap1;
+ propertyMap1.Add( DevelImageVisual::Property::LOOP_COUNT, 1 )
+ .Add( DevelImageVisual::Property::PLAY_RANGE, Vector2( 0.4f, 0.6f ) );
+
+ visualImpl.SetProperties( propertyMap1 );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ actor.Unparent( );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+
+ END_TEST;
+}
dali-toolkit-test-utils/toolkit-timer.cpp
dali-toolkit-test-utils/toolkit-tts-player.cpp
dali-toolkit-test-utils/toolkit-native-image-source.cpp
+ dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
dali-toolkit-test-utils/toolkit-video-player.cpp
dali-toolkit-test-utils/toolkit-web-engine.cpp
dali-toolkit-test-utils/toolkit-trigger-event-factory.cpp
--- /dev/null
+/*
+ * Copyright (c) 2018 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.
+ *
+ */
+
+#include <dali/devel-api/adaptor-framework/vector-animation-renderer.h>
+#include <dali/public-api/object/base-object.h>
+#include <toolkit-application.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+class VectorAnimationRenderer: public Dali::BaseObject
+{
+public:
+
+ VectorAnimationRenderer( const std::string& url, Dali::Renderer renderer, uint32_t width, uint32_t height )
+ : mUrl( url ),
+ mRenderer( renderer ),
+ mWidth( width ),
+ mHeight( height )
+ {
+ }
+
+ void SetSize( uint32_t width, uint32_t height )
+ {
+ mWidth = width;
+ mHeight = height;
+ }
+
+ bool StartRender()
+ {
+ return true;
+ }
+
+ void StopRender()
+ {
+ }
+
+ void Render( uint32_t frameNumber )
+ {
+ }
+
+ uint32_t GetTotalFrameNumber()
+ {
+ return 5;
+ }
+
+public:
+
+ std::string mUrl;
+ Dali::Renderer mRenderer;
+ uint32_t mWidth;
+ uint32_t mHeight;
+
+};
+
+inline VectorAnimationRenderer& GetImplementation( Dali::VectorAnimationRenderer& renderer )
+{
+ DALI_ASSERT_ALWAYS( renderer && "VectorAnimationRenderer handle is empty." );
+ BaseObject& handle = renderer.GetBaseObject();
+ return static_cast< Internal::Adaptor::VectorAnimationRenderer& >( handle );
+}
+
+inline const VectorAnimationRenderer& GetImplementation( const Dali::VectorAnimationRenderer& renderer )
+{
+ DALI_ASSERT_ALWAYS( renderer && "VectorAnimationRenderer handle is empty." );
+ const BaseObject& handle = renderer.GetBaseObject();
+ return static_cast< const Internal::Adaptor::VectorAnimationRenderer& >( handle );
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+
+/********************************************************************************/
+/********************************* PUBLIC CLASS *******************************/
+/********************************************************************************/
+
+VectorAnimationRenderer VectorAnimationRenderer::New( const std::string& url, Renderer renderer, uint32_t width, uint32_t height )
+{
+ Internal::Adaptor::VectorAnimationRenderer* animationRenderer = new Internal::Adaptor::VectorAnimationRenderer( url, renderer, width, height );
+
+ return VectorAnimationRenderer( animationRenderer );
+}
+
+VectorAnimationRenderer::VectorAnimationRenderer()
+{
+}
+
+VectorAnimationRenderer::~VectorAnimationRenderer()
+{
+}
+
+VectorAnimationRenderer::VectorAnimationRenderer( Internal::Adaptor::VectorAnimationRenderer* internal )
+: BaseHandle( internal )
+{
+}
+
+VectorAnimationRenderer::VectorAnimationRenderer( const VectorAnimationRenderer& handle )
+: BaseHandle( handle )
+{
+}
+
+VectorAnimationRenderer& VectorAnimationRenderer::operator=( const VectorAnimationRenderer& rhs )
+{
+ BaseHandle::operator=( rhs );
+ return *this;
+}
+
+void VectorAnimationRenderer::SetSize( uint32_t width, uint32_t height )
+{
+ Internal::Adaptor::GetImplementation( *this ).SetSize( width, height );
+}
+
+bool VectorAnimationRenderer::StartRender()
+{
+ return Internal::Adaptor::GetImplementation( *this ).StartRender();
+}
+
+void VectorAnimationRenderer::StopRender()
+{
+ Internal::Adaptor::GetImplementation( *this ).StopRender();
+}
+
+void VectorAnimationRenderer::Render( uint32_t frameNumber )
+{
+ Internal::Adaptor::GetImplementation( *this ).Render( frameNumber );
+}
+
+uint32_t VectorAnimationRenderer::GetTotalFrameNumber()
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetTotalFrameNumber();
+}
+
+} // namespace Dali;
+
END_TEST;
}
+int UtcDaliVisualFactoryGetAnimatedVectorImageVisual03(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliVisualFactoryGetAnimatedVectorImageVisual03: Request animated vector image visual with a Property::Map" );
+
+ Property::Map propertyMap;
+ propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( DevelImageVisual::Property::LOOP_COUNT, 3 )
+ .Add( DevelImageVisual::Property::PLAY_RANGE, Vector2( 0.2f, 0.8f ) );
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ actor.SetSize( 200.0f, 200.0f );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ // Wait for resource ready event callback
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ actor.Unparent( );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+
+ END_TEST;
+}
+
+int UtcDaliVisualFactoryGetAnimatedVectorImageVisual04(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliVisualFactoryGetAnimatedVectorImageVisual04: Request animated vector image visual with a Property::Map" );
+
+ Property::Map propertyMap;
+ propertyMap.Add( "visualType", DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( "url", TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( "loopCount", 3 )
+ .Add( "playRange", Vector2( 0.2f, 0.8f ) );
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ actor.SetSize( 200.0f, 200.0f );
+ Stage::GetCurrent().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ // Wait for resource ready event callback
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ actor.Unparent( );
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+
+ END_TEST;
+}
+
int UtcDaliAnimatedVectorImageVisualGetPropertyMap01(void)
{
ToolkitTestApplication application;
tet_infoline( "UtcDaliAnimatedVectorImageVisualGetPropertyMap01" );
+ Vector2 playRange( 0.2f, 0.8f );
+
Property::Map propertyMap;
propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
- .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME );
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( DevelImageVisual::Property::LOOP_COUNT, 3 )
+ .Add( DevelImageVisual::Property::PLAY_RANGE, playRange );
// request AnimatedVectorImageVisual with a property map
VisualFactory factory = VisualFactory::Get();
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get< std::string >() == TEST_VECTOR_IMAGE_FILE_NAME );
+ value = resultMap.Find( DevelImageVisual::Property::LOOP_COUNT, Property::INTEGER );
+ DALI_TEST_CHECK( value );
+ DALI_TEST_CHECK( value->Get< int >() == 3 );
+
+ value = resultMap.Find( DevelImageVisual::Property::PLAY_RANGE, Property::VECTOR2 );
+ DALI_TEST_CHECK( value );
+ DALI_TEST_CHECK( value->Get< Vector2 >() == playRange );
+
// request AnimatedVectorImageVisual with an URL
Visual::Base visual2 = factory.CreateVisual( TEST_VECTOR_IMAGE_FILE_NAME, ImageDimensions() );
END_TEST;
}
+
+int UtcDaliAnimatedVectorImageVisualLoopCount(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliAnimatedVectorImageVisualLoopCount" );
+
+ Property::Map propertyMap;
+ propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( DevelImageVisual::Property::LOOP_COUNT, 3 );
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+ Vector2 controlSize( 20.f, 30.f );
+ actor.SetSize( controlSize );
+
+ Stage::GetCurrent().Add( actor );
+
+ Property::Map attributes;
+ DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ END_TEST;
+}
+
+int UtcDaliAnimatedVectorImageVisualPlayRange(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliAnimatedVectorImageVisualPlayRange" );
+
+ Vector2 playRange( 0.8f, 0.2f );
+
+ Property::Map propertyMap;
+ propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME )
+ .Add( DevelImageVisual::Property::PLAY_RANGE, playRange );
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+ Vector2 controlSize( 20.f, 30.f );
+ actor.SetSize( controlSize );
+
+ Stage::GetCurrent().Add( actor );
+
+ Property::Map attributes;
+ DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ END_TEST;
+}
DragSignalFunctor functor(data);
detector.StartedSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(control, data.control, TEST_LOCATION);
- DALI_TEST_EQUALS(Vector2(10.0f, 10.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(12.0f, 12.0f), data.detector.GetCurrentScreenPosition(), TEST_LOCATION);
data.Reset();
END_TEST;
DragSignalFunctor functor(data);
detector.EnteredSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
- screenCoordinates.x = 10.0f;
- screenCoordinates.y = 110.0f;
+ Vector2 screenCoordinates(10.0f, 110.0f);
application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates));
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DragSignalFunctor functor(data);
detector.MovedSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
- screenCoordinates.x = 10.0f;
- screenCoordinates.y = 110.0f;
+ Vector2 screenCoordinates(10.0f, 110.0f);
application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates));
screenCoordinates.x = 10.0f;
DragSignalFunctor functor(data);
detector.ExitedSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
- screenCoordinates.x = 10.0f;
- screenCoordinates.y = 110.0f;
+ Vector2 screenCoordinates(10.0f, 110.0f);
application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates));
screenCoordinates.x = 20.0f;
DragSignalFunctor functor(data);
detector.DroppedSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
- screenCoordinates.x = 10.0f;
- screenCoordinates.y = 110.0f;
+ Vector2 screenCoordinates(10.0f, 110.0f);
application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates));
screenCoordinates.x = 10.0f;
DragSignalFunctor functor(data);
detector.DroppedSignal().Connect(&application, functor);
- Vector2 screenCoordinates(10.0f, 10.0f);
- application.ProcessEvent(GenerateSingleTouch(TouchPoint::Down, screenCoordinates));
+ application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
+ application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 10.0f), Vector2(12.0f, 12.0f), 10));
- screenCoordinates.x = 10.0f;
- screenCoordinates.y = 110.0f;
+ Vector2 screenCoordinates(10.0f, 110.0f);
application.ProcessEvent(GenerateSingleTouch(TouchPoint::Motion, screenCoordinates));
screenCoordinates.x = 10.0f;
*/
LOOP_COUNT = ORIENTATION_CORRECTION + 3,
+ /**
+ * @brief The playing range the AnimatedVectorImageVisual will use.
+ *
+ * Animation will play between the values specified. Both values should be between 0-1,
+ * otherwise they will be ignored. If the range provided is not in proper order ( minimum,maximum ), it will be reordered.
+ *
+ * @details Name "playRange", Type Property::VECTOR2, between 0 and 1
+ * @note Default 0 and 1
+ */
+ PLAY_RANGE = ORIENTATION_CORRECTION + 4
+
};
} //namespace Property
const unsigned int ALIGNMENT_STRING_TABLE_COUNT = sizeof( ALIGNMENT_STRING_TABLE ) / sizeof( ALIGNMENT_STRING_TABLE[0] );
-const Property::Index GET_VISUAL_INDEX_FOR_STATE[][Button::STATE_COUNT] =
+const Property::Index VISUAL_INDEX_FOR_STATE[][Button::STATE_COUNT] =
{
{ Toolkit::DevelButton::Property::UNSELECTED_BACKGROUND_VISUAL, Toolkit::DevelButton::Property::UNSELECTED_VISUAL },
{ Toolkit::DevelButton::Property::SELECTED_BACKGROUND_VISUAL, Toolkit::DevelButton::Property::SELECTED_VISUAL },
return transitionTable[mButtonState][requestedState];
}
-void Button::PerformFunctionOnVisualsInState( void(Button::*functionPtr)( Property::Index visualIndex), State state )
-{
- DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "Button::PerformFunctionOnVisualsInState BACKROUND visual(%d) for state (%d)\n",
- GET_VISUAL_INDEX_FOR_STATE[state][BACKGROUND], state );
- DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "Button::PerformFunctionOnVisualsInState FOREGROUND visuals(%d) for state (%d)\n",
- GET_VISUAL_INDEX_FOR_STATE[state][FOREGROUND], state );
-
- (this->*functionPtr)( GET_VISUAL_INDEX_FOR_STATE[state][BACKGROUND] );
- (this->*functionPtr)( GET_VISUAL_INDEX_FOR_STATE[state][FOREGROUND] );
-
- RelayoutRequest();
-}
-
void Button::ChangeState( State requestedState )
{
DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "Button::ChangeState ReuestedState(%d)\n", requestedState );
if ( Self().OnStage() )
{
OnStateChange( mButtonState ); // Notify derived buttons
- PerformFunctionOnVisualsInState( &Button::SelectRequiredVisual, mButtonState );
+ SelectRequiredVisual( VISUAL_INDEX_FOR_STATE[ mButtonState ][ BACKGROUND ] );
+ SelectRequiredVisual( VISUAL_INDEX_FOR_STATE[ mButtonState ][ FOREGROUND ] );
// If animation supported then visual removal should be performed after any transition animation has completed.
// If Required Visual is not loaded before current visual is removed then a flickering will be evident.
- PerformFunctionOnVisualsInState( &Button::OnButtonVisualRemoval, mPreviousButtonState ); // Derived button can override OnButtonVisualRemoval
+ // Derived button can override OnButtonVisualRemoval
+ OnButtonVisualRemoval( VISUAL_INDEX_FOR_STATE[ mPreviousButtonState ][ BACKGROUND ] );
+ OnButtonVisualRemoval( VISUAL_INDEX_FOR_STATE[ mPreviousButtonState ][ FOREGROUND ] );
+ RelayoutRequest();
}
Toolkit::Button handle( GetOwner() );
* 3) Register visual with control with false for enable flag. Button will later enable visual when needed ( Button::SelectRequiredVisual )
* 4) Unregister visual if empty map was provided. This is the method to remove a visual
*/
-
void Button::CreateVisualsForComponent( Property::Index index, const Property::Value& value, const int visualDepth )
{
DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "CreateVisualsForComponent index(%d)\n", index );
{
DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "CreateVisualsForComponent RegisterVisual index(%d) enabled(%s)\n",
index, DevelControl::IsVisualEnabled( *this, index )?"true":"false" );
- DevelControl::RegisterVisual( *this, index, buttonVisual, DevelControl::IsVisualEnabled( *this, index ), visualDepth );
+ // enable the visual if needed for current state
+ const bool enabled = ( ( index == VISUAL_INDEX_FOR_STATE[ mButtonState ][ BACKGROUND ] )||
+ ( index == VISUAL_INDEX_FOR_STATE[ mButtonState ][ FOREGROUND ] ) );
+ DevelControl::RegisterVisual( *this, index, buttonVisual, enabled, visualDepth );
}
else
{
DevelControl::UnregisterVisual( *this, index );
DALI_LOG_INFO( gLogButtonFilter, Debug::General, "CreateVisualsForComponent Visual not created or empty map (clearing visual).(%d)\n", index);
}
- PerformFunctionOnVisualsInState( &Button::SelectRequiredVisual, mButtonState );
+ RelayoutRequest();
}
bool Button::GetPropertyMapForVisual( Property::Index visualIndex, Property::Map& retreivedMap ) const
void Button::OnStageConnection( int depth )
{
DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "Button::OnStageConnection ptr(%p) \n", this );
- PerformFunctionOnVisualsInState( &Button::OnButtonVisualRemoval, mPreviousButtonState );
+ OnButtonVisualRemoval( VISUAL_INDEX_FOR_STATE[ mPreviousButtonState ][ BACKGROUND ] );
+ OnButtonVisualRemoval( VISUAL_INDEX_FOR_STATE[ mPreviousButtonState ][ FOREGROUND ] );
SelectRequiredVisual( Toolkit::Button::Property::LABEL );
- PerformFunctionOnVisualsInState( &Button::SelectRequiredVisual, mButtonState );
+ SelectRequiredVisual( VISUAL_INDEX_FOR_STATE[ mButtonState ][ BACKGROUND ] );
+ SelectRequiredVisual( VISUAL_INDEX_FOR_STATE[ mButtonState ][ FOREGROUND ] );
Control::OnStageConnection( depth ); // Enabled visuals will be put on stage
+ RelayoutRequest();
}
Vector3 Button::GetNaturalSize()
for ( int state = Button::UNSELECTED_STATE; state < Button::STATE_COUNT; state++ )
{
- Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, GET_VISUAL_INDEX_FOR_STATE[state][FOREGROUND] );
+ Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, VISUAL_INDEX_FOR_STATE[state][FOREGROUND] );
Size visualSize;
if ( visual )
{
{
for ( int state = Button::UNSELECTED_STATE; state < Button::STATE_COUNT; state++ )
{
- Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, GET_VISUAL_INDEX_FOR_STATE[state][BACKGROUND] );
+ Toolkit::Visual::Base visual = DevelControl::GetVisual( *this, VISUAL_INDEX_FOR_STATE[state][BACKGROUND] );
Size visualSize;
if ( visual )
{
{
DALI_LOG_INFO( gLogButtonFilter, Debug::General, "OnRelayout targetSize(%f,%f) ptr(%p) state[%d]\n", size.width, size.height, this, mButtonState );
- Toolkit::Visual::Base currentVisual = DevelControl::GetVisual( *this, GET_VISUAL_INDEX_FOR_STATE[mButtonState][FOREGROUND] );
-
- Toolkit::Visual::Base currentBackGroundVisual = DevelControl::GetVisual( *this, GET_VISUAL_INDEX_FOR_STATE[mButtonState][BACKGROUND] );
+ Toolkit::Visual::Base currentVisual = DevelControl::GetVisual( *this, VISUAL_INDEX_FOR_STATE[mButtonState][FOREGROUND] );
+ Toolkit::Visual::Base currentBackGroundVisual = DevelControl::GetVisual( *this, VISUAL_INDEX_FOR_STATE[mButtonState][BACKGROUND] );
// Sizes and padding set to zero, if not present then values will no effect calculations.
Vector2 visualPosition = Vector2::ZERO;
void Button::SelectRequiredVisual( Property::Index visualIndex )
{
DALI_LOG_INFO( gLogButtonFilter, Debug::Verbose, "Button::SelectRequiredVisual index(%d) state(%d)\n", visualIndex, mButtonState );
-
- DevelControl::EnableVisual( *this, visualIndex, true );
+ // only enable visuals that exist
+ if( DevelControl::GetVisual( *this, visualIndex ) )
+ {
+ DevelControl::EnableVisual( *this, visualIndex, true );
+ }
}
void Button::RemoveVisual( Property::Index visualIndex )
if( !outTextVisualProperties.Empty() )
{
GetImplementation( button ).CreateVisualsForComponent( index, outTextVisualProperties, DepthIndex::CONTENT );
- GetImplementation( button ).RelayoutRequest();
}
break;
}
labelAlignment );
GetImplementation( button ).SetLabelAlignment( labelAlignment );
- GetImplementation( button ).RelayoutRequest();
break;
}
{
Vector4 padding ( value.Get< Vector4 >() );
GetImplementation( button ).SetForegroundPadding( Padding( padding.x, padding.y, padding.z, padding.w ) );
- GetImplementation( button ).RelayoutRequest();
break;
}
}
bool ValidateState( State requestedState );
/**
- * Perform the given function on the visuals in the given state. Can be used to add and remove visuals.
- * @param[in] functionPtr pointer to the function to perform an action on a visual
- * @param[in] state Visuals in this state will be the target
- */
- void PerformFunctionOnVisualsInState( void(Button::*functionPtr)( Property::Index visualIndex), State state );
-
- /**
* Changes the button state when an action occurs on it
* @param[in] requestedState the state to change to
*/
if(gesture.state == Gesture::Started)
{
mDragLocalPosition = gesture.position;
- }
- if(gesture.state == Gesture::Continuing)
- {
- Vector2 screenPosition = gesture.screenPosition;
- control.GetParent().ScreenToLocal(mLocalPosition.x, mLocalPosition.y, screenPosition.x, screenPosition.y);
- mShadowControl.SetPosition(mLocalPosition.x - mDragLocalPosition.x, mLocalPosition.y - mDragLocalPosition.y);
- }
- if(gesture.state == Gesture::Finished)
- {
- mDragControl.GetParent().Remove(mShadowControl);
- EmitEndedSignal(control);
- }
-}
-
-bool DragAndDropDetector::OnDrag(Dali::Actor actor, const Dali::TouchData& data)
-{
- Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor);
- PointState::Type type = data.GetState(0);
- if(type == PointState::DOWN)
- {
mPointDown = true;
mDragControl = control;
mFirstEnter.clear();
mShadowControl.SetParentOrigin(control.GetCurrentParentOrigin());
mShadowControl.SetAnchorPoint(control.GetCurrentAnchorPoint());
control.GetParent().Add(mShadowControl);
- SetPosition(data.GetScreenPosition(0));
+ SetPosition(gesture.screenPosition);
EmitStartedSignal(control);
}
+ if(gesture.state == Gesture::Continuing)
+ {
+ Vector2 screenPosition = gesture.screenPosition;
+ control.GetParent().ScreenToLocal(mLocalPosition.x, mLocalPosition.y, screenPosition.x, screenPosition.y);
+ mShadowControl.SetPosition(mLocalPosition.x - mDragLocalPosition.x, mLocalPosition.y - mDragLocalPosition.y);
+ }
+ if(gesture.state == Gesture::Finished)
+ {
+ mDragControl.GetParent().Remove(mShadowControl);
+ EmitEndedSignal(control);
+ }
+}
+
+bool DragAndDropDetector::OnDrag(Dali::Actor actor, const Dali::TouchData& data)
+{
+ Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor);
+ PointState::Type type = data.GetState(0);
if(type == PointState::MOTION)
{
$(toolkit_src_dir)/visuals/animated-image/rolling-image-cache.cpp \
$(toolkit_src_dir)/visuals/animated-image/rolling-gif-image-cache.cpp \
$(toolkit_src_dir)/visuals/animated-vector-image/animated-vector-image-visual.cpp \
- $(toolkit_src_dir)/visuals/animated-vector-image/vector-image-rasterize-thread.cpp \
+ $(toolkit_src_dir)/visuals/animated-vector-image/vector-rasterize-thread.cpp \
$(toolkit_src_dir)/visuals/border/border-visual.cpp \
$(toolkit_src_dir)/visuals/color/color-visual.cpp \
$(toolkit_src_dir)/visuals/gradient/gradient-visual.cpp \
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
#include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
-#include <dali-toolkit/internal/visuals/animated-vector-image/vector-image-rasterize-thread.h>
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h>
namespace Dali
{
{
const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
+constexpr auto LOOP_FOREVER = -1;
} // unnamed namespace
mImageVisualShaderFactory( shaderFactory ),
mUrl( imageUrl ),
mVisualSize(),
+ mPlayRange( 0.0f, 1.0f ),
mPlacementActor(),
mVectorRasterizeThread(),
+ mLoopCount( LOOP_FOREVER ),
mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP )
{
// the rasterized image is with pre-multiplied alpha format
{
map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
}
+ map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast< int >( mLoopCount ) );
+ map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, static_cast< Vector2 >( mPlayRange ) );
}
void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
{
DoSetProperty( keyValue.first.indexKey, keyValue.second );
}
+ else
+ {
+ if( keyValue.first == LOOP_COUNT_NAME )
+ {
+ DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
+ }
+ else if( keyValue.first == PLAY_RANGE_NAME )
+ {
+ DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second );
+ }
+ }
}
}
void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
{
+ switch(index)
+ {
+ case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
+ {
+ int32_t loopCount;
+ if( value.Get( loopCount ) )
+ {
+ mLoopCount = loopCount;
+ if( mVectorRasterizeThread )
+ {
+ mVectorRasterizeThread->SetLoopCount( loopCount );
+ }
+ }
+ break;
+ }
+ case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
+ {
+ Vector2 range;
+ if( value.Get( range ) )
+ {
+ // Make sure the range specified is between 0.0 and 1.0
+ if( range.x >= 0.0f && range.x <= 1.0f && range.y >= 0.0f && range.y <= 1.0f )
+ {
+ Vector2 orderedRange( range );
+ // If the range is not in order swap values
+ if( range.x > range.y )
+ {
+ orderedRange = Vector2( range.y, range.x );
+ }
+
+ mPlayRange = orderedRange;
+
+ if( mVectorRasterizeThread )
+ {
+ mVectorRasterizeThread->SetPlayRange( mPlayRange );
+ }
+ }
+ }
+ break;
+ }
+ }
}
void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
mVectorRasterizeThread = std::unique_ptr< VectorRasterizeThread >( new VectorRasterizeThread( mUrl.GetUrl(), mImpl->mRenderer, width, height ) );
mVectorRasterizeThread->SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
+ mVectorRasterizeThread->SetLoopCount( mLoopCount );
+ mVectorRasterizeThread->SetPlayRange( mPlayRange );
+
mVectorRasterizeThread->Start();
if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
}
else
{
- // TODO: change size
+ uint32_t width = static_cast< uint32_t >( visualSize.width );
+ uint32_t height = static_cast< uint32_t >( visualSize.height );
+
+ mVectorRasterizeThread->SetSize( width, height );
}
}
}
ImageVisualShaderFactory& mImageVisualShaderFactory;
VisualUrl mUrl;
Vector2 mVisualSize;
+ Vector2 mPlayRange;
WeakHandle< Actor > mPlacementActor;
std::unique_ptr< VectorRasterizeThread > mVectorRasterizeThread;
+
+ int32_t mLoopCount;
DevelAnimatedVectorImageVisual::Action::Type mActionStatus;
};
*/
// CLASS HEADER
-#include <dali-toolkit/internal/visuals/animated-vector-image/vector-image-rasterize-thread.h>
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h>
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/thread-settings.h>
namespace
{
+constexpr auto LOOP_FOREVER = -1;
+
#if defined(DEBUG_ENABLED)
Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
#endif
VectorRasterizeThread::VectorRasterizeThread( const std::string& url, Renderer renderer, uint32_t width, uint32_t height )
: mUrl( url ),
mVectorRenderer(),
+ mConditionalWait(),
+ mMutex(),
mResourceReadyTrigger( NULL ),
+ mPlayRange( 0.0f, 1.0f ),
mCurrentFrame( 0 ),
mTotalFrame( 0 ),
+ mStartFrame( 0 ),
+ mEndFrame( 0 ),
mWidth( width ),
mHeight( height ),
+ mLoopCount( LOOP_FOREVER ),
+ mCurrentLoop( 0 ),
mNeedRender( false ),
mPlaying( false ),
mPaused( false ),
}
}
+void VectorRasterizeThread::SetSize( uint32_t width, uint32_t height )
+{
+ ConditionalWait::ScopedLock lock( mConditionalWait );
+ mVectorRenderer.SetSize( width, height );
+
+ DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::SetSize: width = %d, height = %d\n", width, height );
+}
+
void VectorRasterizeThread::StartAnimation()
{
ConditionalWait::ScopedLock lock( mConditionalWait );
void VectorRasterizeThread::SetResourceReadyCallback( EventThreadCallback* callback )
{
+ ConditionalWait::ScopedLock lock( mConditionalWait );
mResourceReadyTrigger = callback;
}
+void VectorRasterizeThread::SetLoopCount( int16_t count )
+{
+ ConditionalWait::ScopedLock lock( mConditionalWait );
+
+ mLoopCount = count;
+
+ // Reset progress
+ mCurrentLoop = 0;
+ mCurrentFrame = mStartFrame;
+}
+
+void VectorRasterizeThread::SetPlayRange( Vector2 range )
+{
+ ConditionalWait::ScopedLock lock( mConditionalWait );
+
+ mPlayRange = range;
+
+ if( mTotalFrame != 0 )
+ {
+ mStartFrame = static_cast< uint32_t >( mPlayRange.x * mTotalFrame + 0.5f );
+ mEndFrame = static_cast< uint32_t >( mPlayRange.y * mTotalFrame + 0.5f );
+ }
+}
+
bool VectorRasterizeThread::IsThreadReady()
{
ConditionalWait::ScopedLock lock( mConditionalWait );
if( !mPlaying )
{
- mCurrentFrame = 0;
+ mCurrentFrame = mStartFrame;
+ mCurrentLoop = 0;
}
mConditionalWait.Wait( lock );
mTotalFrame = mVectorRenderer.GetTotalFrameNumber();
- DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::StartRender: Renderer is started [%d]\n", mTotalFrame );
+ mStartFrame = static_cast< uint32_t >( mPlayRange.x * mTotalFrame + 0.5f );
+ mEndFrame = static_cast< uint32_t >( mPlayRange.y * mTotalFrame + 0.5f );
+
+ mCurrentFrame = mStartFrame;
+
+ DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::StartRender: Renderer is started [%d (%d, %d)]\n", mTotalFrame, mStartFrame, mEndFrame );
return true;
}
if( mPlaying && !mPaused )
{
- mCurrentFrame++;
-
- if( mCurrentFrame >= mTotalFrame )
+ if( ++mCurrentFrame >= mEndFrame )
{
- mCurrentFrame = 0;
+ if( mLoopCount < 0 )
+ {
+ // repeat forever
+ mCurrentFrame = mStartFrame;
+ }
+ else
+ {
+ mCurrentLoop++;
+ if( mCurrentLoop >= mLoopCount )
+ {
+ // Animation is finished
+ mPlaying = false;
+ }
+ else
+ {
+ mCurrentFrame = mStartFrame;
+ }
+ }
}
}
virtual ~VectorRasterizeThread();
/**
- * @brief Play the vector animation
+ * @brief Sets the target image size.
+ *
+ * @param[in] width The target image width
+ * @param[in] height The target image height
+ */
+ void SetSize( uint32_t width, uint32_t height );
+
+ /**
+ * @brief Play the vector animation.
*/
void StartAnimation();
/**
- * @brief Stop the vector animation
+ * @brief Stop the vector animation.
*/
void StopAnimation();
/**
- * @brief Pause the vector animation
+ * @brief Pause the vector animation.
*/
void PauseAnimation();
/**
- * @brief Resume the vector animation
+ * @brief Resume the vector animation.
*/
void ResumeAnimation();
/**
* @brief This callback is called after the first frame is ready.
- * @param callback The resource ready callback
+ * @param[in] callback The resource ready callback
*/
void SetResourceReadyCallback( EventThreadCallback* callback );
+ /**
+ * @brief Enable looping for 'count' repeats. -1 means to repeat forever.
+ * @param[in] count The number of times to loop
+ */
+ void SetLoopCount( int16_t count );
+
+ /**
+ * @brief Set the playing range.
+ * @param[in] range Two values between [0,1] to specify minimum and maximum progress.
+ * The animation will play between those values.
+ */
+ void SetPlayRange( Vector2 range );
+
protected:
/**
ConditionalWait mConditionalWait;
Dali::Mutex mMutex;
EventThreadCallback* mResourceReadyTrigger;
+ Vector2 mPlayRange;
uint32_t mCurrentFrame;
uint32_t mTotalFrame;
+ uint32_t mStartFrame;
+ uint32_t mEndFrame;
uint32_t mWidth;
uint32_t mHeight;
+ int16_t mLoopCount;
+ int16_t mCurrentLoop;
bool mNeedRender;
bool mPlaying;
bool mPaused;
const char * const ORIENTATION_CORRECTION_NAME("orientationCorrection");
const char * const AUXILIARY_IMAGE_NAME("auxiliaryImage");
const char * const AUXILIARY_IMAGE_ALPHA_NAME("auxiliaryImageAlpha");
+const char * const PLAY_RANGE_NAME("playRange");
// Text visual
const char * const TEXT_PROPERTY( "text" );
extern const char * const ORIENTATION_CORRECTION_NAME;
extern const char * const AUXILLARY_IMAGE_NAME;
extern const char * const AUXILLARY_IMAGE_ALPHA_NAME;
+extern const char * const PLAY_RANGE_NAME;
// Text visual
extern const char * const TEXT_PROPERTY;
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 3;
-const unsigned int TOOLKIT_MICRO_VERSION = 52;
+const unsigned int TOOLKIT_MICRO_VERSION = 53;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali-toolkit
Summary: Dali 3D engine Toolkit
-Version: 1.3.52
+Version: 1.3.53
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff