X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fanimated-vector-image%2Fanimated-vector-image-visual.cpp;h=93c096624e41827e9813698cd5d6c8b9311d616a;hp=96c7dddc2b8fd163aade4e130d054de1c4be3bf6;hb=b86fa7f2bedebe580b0e9a20f9b42cf2d628fafa;hpb=79267e9786ebcba2b4d79e2f8f75d9b01610e29d diff --git a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp index 96c7ddd..93c0966 100644 --- a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp +++ b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,19 +19,21 @@ #include // EXTERNAL INCLUDES -#include -#include +#include +#include +#include #include // INTERNAL INCLUDES #include #include #include +#include #include #include #include #include -#include +#include namespace Dali { @@ -46,7 +48,23 @@ namespace { const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f ); -constexpr auto LOOP_FOREVER = -1; + +// stop behavior +DALI_ENUM_TO_STRING_TABLE_BEGIN( STOP_BEHAVIOR ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME ) +DALI_ENUM_TO_STRING_TABLE_END( STOP_BEHAVIOR ) + +// looping mode +DALI_ENUM_TO_STRING_TABLE_BEGIN( LOOPING_MODE ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::LoopingMode, RESTART ) +DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::LoopingMode, AUTO_REVERSE ) +DALI_ENUM_TO_STRING_TABLE_END( LOOPING_MODE ) + +#if defined(DEBUG_ENABLED) +Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" ); +#endif } // unnamed namespace @@ -66,27 +84,68 @@ AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& } AnimatedVectorImageVisual::AnimatedVectorImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl ) -: Visual::Base( factoryCache, Visual::FittingMode::FILL ), - mImageVisualShaderFactory( shaderFactory ), +: Visual::Base( factoryCache, Visual::FittingMode::FILL, static_cast( Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE ) ), mUrl( imageUrl ), + mAnimationData(), + mVectorAnimationTask( new VectorAnimationTask( factoryCache, imageUrl.GetUrl() ) ), + mImageVisualShaderFactory( shaderFactory ), mVisualSize(), - mPlayRange( 0.0f, 1.0f ), + mVisualScale( Vector2::ONE ), mPlacementActor(), - mVectorRasterizeThread(), - mLoopCount( LOOP_FOREVER ), - mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP ) + mPlayState( DevelImageVisual::PlayState::STOPPED ), + mEventCallback( nullptr ), + mRendererAdded( false ), + mCoreShutdown(false) { // the rasterized image is with pre-multiplied alpha format mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA; + + mVectorAnimationTask->UploadCompletedSignal().Connect( this, &AnimatedVectorImageVisual::OnUploadCompleted ); + mVectorAnimationTask->SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) ); + + auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager(); + vectorAnimationManager.AddObserver(*this); } AnimatedVectorImageVisual::~AnimatedVectorImageVisual() { + if( ! mCoreShutdown ) + { + auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager(); + vectorAnimationManager.RemoveObserver(*this); + + if( mEventCallback ) + { + mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback( mEventCallback ); + } + + // Finalize animation task and disconnect the signal in the main thread + mVectorAnimationTask->UploadCompletedSignal().Disconnect( this, &AnimatedVectorImageVisual::OnUploadCompleted ); + mVectorAnimationTask->Finalize(); + } +} + +void AnimatedVectorImageVisual::VectorAnimationManagerDestroyed() +{ + // Core is shutting down. Don't talk to the plugin any more. + mCoreShutdown = true; } void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize ) { - naturalSize = mVisualSize; + if( mVisualSize != Vector2::ZERO ) + { + naturalSize = mVisualSize; + } + else + { + uint32_t width, height; + mVectorAnimationTask->GetDefaultSize( width, height ); + naturalSize.x = width; + naturalSize.y = height; + } + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::GetNaturalSize: w = %f, h = %f [%p]\n", naturalSize.width, naturalSize.height, this ); } void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const @@ -97,8 +156,26 @@ void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const { 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 ) ); + map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mAnimationData.loopCount ); + + uint32_t startFrame, endFrame; + mVectorAnimationTask->GetPlayRange( startFrame, endFrame ); + + Property::Array playRange; + playRange.PushBack( static_cast< int32_t >( startFrame ) ); + playRange.PushBack( static_cast< int32_t >( endFrame ) ); + map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange ); + + map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int32_t >( mPlayState ) ); + map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast< int32_t >( mVectorAnimationTask->GetCurrentFrameNumber() ) ); + map.Insert( Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast< int32_t >( mVectorAnimationTask->GetTotalFrameNumber() ) ); + + map.Insert( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mAnimationData.stopBehavior ); + map.Insert( Toolkit::DevelImageVisual::Property::LOOPING_MODE, mAnimationData.loopingMode ); + + Property::Map layerInfo; + mVectorAnimationTask->GetLayerInfo( layerInfo ); + map.Insert( Toolkit::DevelImageVisual::Property::CONTENT_INFO, layerInfo ); } void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const @@ -126,8 +203,18 @@ void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMa { DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second ); } + else if( keyValue.first == STOP_BEHAVIOR_NAME ) + { + DoSetProperty( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second ); + } + else if( keyValue.first == LOOPING_MODE_NAME ) + { + DoSetProperty( Toolkit::DevelImageVisual::Property::LOOPING_MODE, keyValue.second ); + } } } + + TriggerVectorRasterization(); } void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value ) @@ -139,57 +226,59 @@ void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Prop int32_t loopCount; if( value.Get( loopCount ) ) { - mLoopCount = loopCount; - if( mVectorRasterizeThread ) - { - mVectorRasterizeThread->SetLoopCount( loopCount ); - } + mAnimationData.loopCount = loopCount; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOP_COUNT; } break; } case Toolkit::DevelImageVisual::Property::PLAY_RANGE: { - Vector2 range; - if( value.Get( range ) ) + const Property::Array* array = value.GetArray(); + if( array ) { - // 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 ); - } - } + mAnimationData.playRange = *array; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE; + } + break; + } + case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR: + { + int32_t stopBehavior = mAnimationData.stopBehavior; + if( Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior ) ) + { + mAnimationData.stopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior ); + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_STOP_BEHAVIOR; + } + break; + } + case Toolkit::DevelImageVisual::Property::LOOPING_MODE: + { + int32_t loopingMode = mAnimationData.loopingMode; + if( Scripting::GetEnumerationProperty( value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode ) ) + { + mAnimationData.loopingMode = DevelImageVisual::LoopingMode::Type( loopingMode ); + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOPING_MODE; } break; } } } -void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor ) +void AnimatedVectorImageVisual::DoSetOnScene( Actor& actor ) { Shader shader; if( mImpl->mCustomShader ) { - shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader, - mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader, + shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader, + mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader, mImpl->mCustomShader->mHints ); shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); } else { - shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true ); + shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true, false ); } Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); @@ -207,146 +296,300 @@ void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor ) // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished. mPlacementActor = actor; - // This visual needs it's size set before it can be rasterized hence set ResourceReady once on stage - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); -} + mVectorAnimationTask->SetRenderer( mImpl->mRenderer ); -void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor ) -{ - if( mVectorRasterizeThread ) + // Add property notification for scaling & size + mScaleNotification = actor.AddPropertyNotification( Actor::Property::WORLD_SCALE, StepCondition( 0.1f, 1.0f ) ); + mScaleNotification.NotifySignal().Connect( this, &AnimatedVectorImageVisual::OnScaleNotification ); + + mSizeNotification = actor.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 3.0f ) ); + mSizeNotification.NotifySignal().Connect( this, &AnimatedVectorImageVisual::OnSizeNotification ); + + DevelActor::VisibilityChangedSignal( actor ).Connect( this, &AnimatedVectorImageVisual::OnControlVisibilityChanged ); + + Window window = DevelWindow::Get( actor ); + if( window ) { - mVectorRasterizeThread->PauseAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED ); - mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE; + DevelWindow::VisibilityChangedSignal( window ).Connect( this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged ); } + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this ); +} + +void AnimatedVectorImageVisual::DoSetOffScene( Actor& actor ) +{ + StopAnimation(); + SendAnimationData(); + if( mImpl->mRenderer ) { actor.RemoveRenderer( mImpl->mRenderer ); mImpl->mRenderer.Reset(); + + mRendererAdded = false; + } + + // Remove property notification + actor.RemovePropertyNotification( mScaleNotification ); + actor.RemovePropertyNotification( mSizeNotification ); + + DevelActor::VisibilityChangedSignal( actor ).Disconnect( this, &AnimatedVectorImageVisual::OnControlVisibilityChanged ); + + Window window = DevelWindow::Get( actor ); + if( window ) + { + DevelWindow::VisibilityChangedSignal( window ).Disconnect( this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged ); } mPlacementActor.Reset(); // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced mVisualSize = Vector2::ZERO; + mVisualScale = Vector2::ONE; + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this ); } void AnimatedVectorImageVisual::OnSetTransform() { Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize ); - if( IsOnStage() ) + if( IsOnScene() && visualSize != mVisualSize ) { - if( visualSize != mVisualSize ) - { - mVisualSize = visualSize; - - if( !mVectorRasterizeThread ) - { - uint32_t width = static_cast< uint32_t >( visualSize.width ); - uint32_t height = static_cast< uint32_t >( visualSize.height ); - - mVectorRasterizeThread = std::unique_ptr< VectorRasterizeThread >( new VectorRasterizeThread( mUrl.GetUrl(), mImpl->mRenderer, width, height ) ); + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this ); - mVectorRasterizeThread->SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) ); - mVectorRasterizeThread->SetLoopCount( mLoopCount ); - mVectorRasterizeThread->SetPlayRange( mPlayRange ); + mVisualSize = visualSize; - mVectorRasterizeThread->Start(); + SetVectorImageSize(); - if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY ) - { - mVectorRasterizeThread->StartAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY ); - } - else - { - // Render one frame - mVectorRasterizeThread->RenderFrame(); - } - } - else - { - uint32_t width = static_cast< uint32_t >( visualSize.width ); - uint32_t height = static_cast< uint32_t >( visualSize.height ); - - mVectorRasterizeThread->SetSize( width, height ); - } + if( mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING ) + { + mAnimationData.playState = DevelImageVisual::PlayState::PLAYING; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE; } + + SendAnimationData(); } } void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes ) { - if( actionId == mActionStatus ) - { - return; - } - // Check if action is valid for this visual type and perform action if possible switch( actionId ) { case DevelAnimatedVectorImageVisual::Action::PLAY: { - if( IsOnStage()) + if( IsOnScene() && mVisualSize != Vector2::ZERO ) { - if( mVectorRasterizeThread ) + if( mAnimationData.playState != DevelImageVisual::PlayState::PLAYING ) { - mVectorRasterizeThread->StartAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY ); //TODO: Should manage this globally + mAnimationData.playState = DevelImageVisual::PlayState::PLAYING; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE; } } - mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY; + mPlayState = DevelImageVisual::PlayState::PLAYING; break; } case DevelAnimatedVectorImageVisual::Action::PAUSE: { - if( mVectorRasterizeThread ) + if( mAnimationData.playState == DevelImageVisual::PlayState::PLAYING ) { - mVectorRasterizeThread->PauseAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED ); + mAnimationData.playState = DevelImageVisual::PlayState::PAUSED; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE; } - mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE; + mPlayState = DevelImageVisual::PlayState::PAUSED; break; } - case DevelAnimatedVectorImageVisual::Action::RESUME: + case DevelAnimatedVectorImageVisual::Action::STOP: { - if( mVectorRasterizeThread ) + if( mAnimationData.playState != DevelImageVisual::PlayState::STOPPED ) { - mVectorRasterizeThread->ResumeAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY ); + mAnimationData.playState = DevelImageVisual::PlayState::STOPPED; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE; } - mActionStatus = DevelAnimatedVectorImageVisual::Action::RESUME; + mPlayState = DevelImageVisual::PlayState::STOPPED; break; } - case DevelAnimatedVectorImageVisual::Action::STOP: + case DevelAnimatedVectorImageVisual::Action::JUMP_TO: { - if( mVectorRasterizeThread ) + int32_t frameNumber; + if( attributes.Get( frameNumber ) ) { - mVectorRasterizeThread->StopAnimation(); - DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED ); + mAnimationData.currentFrame = frameNumber; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME; + } + break; + } + case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY: + { + const Property::Map* map = attributes.GetMap(); + if( map ) + { + DoSetProperties( *map ); } - mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP; break; } } + + TriggerVectorRasterization(); } -void AnimatedVectorImageVisual::OnResourceReady() +void AnimatedVectorImageVisual::OnUploadCompleted() { // If weak handle is holding a placement actor, it is the time to add the renderer to actor. Actor actor = mPlacementActor.GetHandle(); - if( actor ) + if( actor && !mRendererAdded ) { actor.AddRenderer( mImpl->mRenderer ); - // reset the weak handle so that the renderer only get added to actor once - mPlacementActor.Reset(); + mRendererAdded = true; + + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnUploadCompleted: Renderer is added [%p]\n", this ); + } +} + +void AnimatedVectorImageVisual::OnAnimationFinished() +{ + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this ); + + if( mPlayState != DevelImageVisual::PlayState::STOPPED ) + { + mPlayState = DevelImageVisual::PlayState::STOPPED; + + mAnimationData.playState = DevelImageVisual::PlayState::STOPPED; + + if( mImpl->mEventObserver ) + { + mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED ); + } + } + + if( mImpl->mRenderer ) + { + mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED ); + } +} + +void AnimatedVectorImageVisual::SendAnimationData() +{ + if( mAnimationData.resendFlag ) + { + mVectorAnimationTask->SetAnimationData( mAnimationData ); + + if( mImpl->mRenderer ) + { + if( mAnimationData.playState == DevelImageVisual::PlayState::PLAYING ) + { + mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY ); + } + else + { + mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED ); + } + } + + mAnimationData.resendFlag = 0; + } +} + +void AnimatedVectorImageVisual::SetVectorImageSize() +{ + uint32_t width = static_cast< uint32_t >( mVisualSize.width * mVisualScale.width ); + uint32_t height = static_cast< uint32_t >( mVisualSize.height * mVisualScale.height ); + + mAnimationData.width = width; + mAnimationData.height = height; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_SIZE; +} + +void AnimatedVectorImageVisual::StopAnimation() +{ + if( mAnimationData.playState != DevelImageVisual::PlayState::STOPPED ) + { + mAnimationData.playState = DevelImageVisual::PlayState::STOPPED; + mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE; + + mPlayState = DevelImageVisual::PlayState::STOPPED; + } +} + +void AnimatedVectorImageVisual::TriggerVectorRasterization() +{ + if( !mEventCallback && !mCoreShutdown ) + { + mEventCallback = MakeCallback( this, &AnimatedVectorImageVisual::OnProcessEvents ); + auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager(); + vectorAnimationManager.RegisterEventCallback( mEventCallback ); + Stage::GetCurrent().KeepRendering( 0.0f ); // Trigger event processing + } +} + +void AnimatedVectorImageVisual::OnScaleNotification( PropertyNotification& source ) +{ + Actor actor = mPlacementActor.GetHandle(); + if( actor ) + { + Vector3 scale = actor.GetProperty< Vector3 >( Actor::Property::WORLD_SCALE ); + mVisualScale.width = scale.width; + mVisualScale.height = scale.height; + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnScaleNotification: scale = %f, %f [%p]\n", mVisualScale.width, mVisualScale.height, this ); + + SetVectorImageSize(); + SendAnimationData(); + + Stage::GetCurrent().KeepRendering( 0.0f ); // Trigger event processing + } +} + +void AnimatedVectorImageVisual::OnSizeNotification( PropertyNotification& source ) +{ + Actor actor = mPlacementActor.GetHandle(); + if( actor ) + { + Vector3 size = actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ); + mVisualSize.width = size.width; + mVisualSize.height = size.height; + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSizeNotification: size = %f, %f [%p]\n", mVisualSize.width, mVisualSize.height, this ); + + SetVectorImageSize(); + SendAnimationData(); + + Stage::GetCurrent().KeepRendering( 0.0f ); // Trigger event processing + } +} + +void AnimatedVectorImageVisual::OnControlVisibilityChanged( Actor actor, bool visible, DevelActor::VisibilityChange::Type type ) +{ + if( !visible ) + { + StopAnimation(); + TriggerVectorRasterization(); - Stage::GetCurrent().KeepRendering( 0.0f ); + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnControlVisibilityChanged: invisibile. Pause animation [%p]\n", this ); } } +void AnimatedVectorImageVisual::OnWindowVisibilityChanged( Window window, bool visible ) +{ + if( !visible ) + { + StopAnimation(); + TriggerVectorRasterization(); + + DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnWindowVisibilityChanged: invisibile. Pause animation [%p]\n", this ); + } +} + +void AnimatedVectorImageVisual::OnProcessEvents() +{ + SendAnimationData(); + + mEventCallback = nullptr; // The callback will be deleted in the VectorAnimationManager +} + } // namespace Internal } // namespace Toolkit