dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/common/stage.h>
  23 #include <dali/devel-api/rendering/renderer-devel.h>
  24 #include <dali/devel-api/adaptor-framework/window-devel.h>
  25 #include <dali/integration-api/debug.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  29 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  32 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  33 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  34 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  35 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  36 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  37
  38 namespace Dali
  39 {
  40
  41 namespace Toolkit
  42 {
  43
  44 namespace Internal
  45 {
  46
  47 namespace
  48 {
  49
  50 const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
  51
  52 // stop behavior
  53 DALI_ENUM_TO_STRING_TABLE_BEGIN( STOP_BEHAVIOR )
  54 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME )
  55 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME )
  56 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME )
  57 DALI_ENUM_TO_STRING_TABLE_END( STOP_BEHAVIOR )
  58
  59 // looping mode
  60 DALI_ENUM_TO_STRING_TABLE_BEGIN( LOOPING_MODE )
  61 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::LoopingMode, RESTART )
  62 DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::DevelImageVisual::LoopingMode, AUTO_REVERSE )
  63 DALI_ENUM_TO_STRING_TABLE_END( LOOPING_MODE )
  64
  65 #if defined(DEBUG_ENABLED)
  66 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
  67 #endif
  68
  69 } // unnamed namespace
  70
  71 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
  72 {
  73   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  74   visual->SetProperties( properties );
  75   visual->Initialize();
  76   return visual;
  77 }
  78
  79 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  80 {
  81   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  82   visual->Initialize();
  83   return visual;
  84 }
  85
  86 AnimatedVectorImageVisual::AnimatedVectorImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  87 : Visual::Base( factoryCache, Visual::FittingMode::FILL, static_cast<Toolkit::Visual::Type>( Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE ) ),
  88   mUrl( imageUrl ),
  89   mAnimationData(),
  90   mVectorAnimationTask( new VectorAnimationTask( factoryCache, imageUrl.GetUrl() ) ),
  91   mImageVisualShaderFactory( shaderFactory ),
  92   mVisualSize(),
  93   mVisualScale( Vector2::ONE ),
  94   mPlacementActor(),
  95   mPlayState( DevelImageVisual::PlayState::STOPPED ),
  96   mEventCallback( nullptr ),
  97   mRendererAdded( false ),
  98   mCoreShutdown(false),
  99   mRedrawInScalingDown(true)
 100 {
 101   // the rasterized image is with pre-multiplied alpha format
 102   mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
 103
 104   mVectorAnimationTask->UploadCompletedSignal().Connect( this, &AnimatedVectorImageVisual::OnUploadCompleted );
 105   mVectorAnimationTask->SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) );
 106
 107   auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 108   vectorAnimationManager.AddObserver(*this);
 109 }
 110
 111 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
 112 {
 113   if( ! mCoreShutdown )
 114   {
 115     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 116     vectorAnimationManager.RemoveObserver(*this);
 117
 118     if( mEventCallback )
 119     {
 120       mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback( mEventCallback );
 121     }
 122
 123     // Finalize animation task and disconnect the signal in the main thread
 124     mVectorAnimationTask->UploadCompletedSignal().Disconnect( this, &AnimatedVectorImageVisual::OnUploadCompleted );
 125     mVectorAnimationTask->Finalize();
 126   }
 127 }
 128
 129 void AnimatedVectorImageVisual::VectorAnimationManagerDestroyed()
 130 {
 131   // Core is shutting down. Don't talk to the plugin any more.
 132   mCoreShutdown = true;
 133 }
 134
 135 void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize )
 136 {
 137   if( mVisualSize != Vector2::ZERO )
 138   {
 139     naturalSize = mVisualSize;
 140   }
 141   else
 142   {
 143     uint32_t width, height;
 144     mVectorAnimationTask->GetDefaultSize( width, height );
 145     naturalSize.x = width;
 146     naturalSize.y = height;
 147   }
 148
 149   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::GetNaturalSize: w = %f, h = %f [%p]\n", naturalSize.width, naturalSize.height, this );
 150 }
 151
 152 void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 153 {
 154   map.Clear();
 155   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE );
 156   if( mUrl.IsValid() )
 157   {
 158     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
 159   }
 160   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mAnimationData.loopCount );
 161
 162   uint32_t startFrame, endFrame;
 163   mVectorAnimationTask->GetPlayRange( startFrame, endFrame );
 164
 165   Property::Array playRange;
 166   playRange.PushBack( static_cast< int32_t >( startFrame ) );
 167   playRange.PushBack( static_cast< int32_t >( endFrame ) );
 168   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange );
 169
 170   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int32_t >( mPlayState ) );
 171   map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast< int32_t >( mVectorAnimationTask->GetCurrentFrameNumber() ) );
 172   map.Insert( Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast< int32_t >( mVectorAnimationTask->GetTotalFrameNumber() ) );
 173
 174   map.Insert( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mAnimationData.stopBehavior );
 175   map.Insert( Toolkit::DevelImageVisual::Property::LOOPING_MODE, mAnimationData.loopingMode );
 176   map.Insert( Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, mRedrawInScalingDown );
 177
 178   Property::Map layerInfo;
 179   mVectorAnimationTask->GetLayerInfo( layerInfo );
 180   map.Insert( Toolkit::DevelImageVisual::Property::CONTENT_INFO, layerInfo );
 181 }
 182
 183 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 184 {
 185   // Do nothing
 186 }
 187
 188 void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMap )
 189 {
 190   // url already passed in from constructor
 191   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 192   {
 193     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 194     if( keyValue.first.type == Property::Key::INDEX )
 195     {
 196       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 197     }
 198     else
 199     {
 200        if( keyValue.first == LOOP_COUNT_NAME )
 201        {
 202           DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 203        }
 204        else if( keyValue.first == PLAY_RANGE_NAME )
 205        {
 206           DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second );
 207        }
 208        else if( keyValue.first == STOP_BEHAVIOR_NAME )
 209        {
 210           DoSetProperty( Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second );
 211        }
 212        else if( keyValue.first == LOOPING_MODE_NAME )
 213        {
 214           DoSetProperty( Toolkit::DevelImageVisual::Property::LOOPING_MODE, keyValue.second );
 215        }
 216        else if( keyValue.first == REDRAW_IN_SCALING_DOWN_NAME )
 217        {
 218           DoSetProperty( Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, keyValue.second );
 219        }
 220     }
 221   }
 222
 223   TriggerVectorRasterization();
 224 }
 225
 226 void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 227 {
 228   switch(index)
 229   {
 230     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 231     {
 232       int32_t loopCount;
 233       if( value.Get( loopCount ) )
 234       {
 235         mAnimationData.loopCount = loopCount;
 236         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOP_COUNT;
 237       }
 238       break;
 239     }
 240     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 241     {
 242       const Property::Array* array = value.GetArray();
 243       if( array )
 244       {
 245         mAnimationData.playRange = *array;
 246         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE;
 247       }
 248       break;
 249     }
 250     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 251     {
 252       int32_t stopBehavior = mAnimationData.stopBehavior;
 253       if( Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior ) )
 254       {
 255         mAnimationData.stopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior );
 256         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_STOP_BEHAVIOR;
 257       }
 258       break;
 259     }
 260     case Toolkit::DevelImageVisual::Property::LOOPING_MODE:
 261     {
 262       int32_t loopingMode = mAnimationData.loopingMode;
 263       if( Scripting::GetEnumerationProperty( value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode ) )
 264       {
 265         mAnimationData.loopingMode = DevelImageVisual::LoopingMode::Type( loopingMode );
 266         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOPING_MODE;
 267       }
 268       break;
 269     }
 270     case Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN:
 271     {
 272       bool redraw;
 273       if( value.Get( redraw ) )
 274       {
 275         mRedrawInScalingDown = redraw;
 276       }
 277       break;
 278     }
 279   }
 280 }
 281
 282 void AnimatedVectorImageVisual::OnInitialize(void)
 283 {
 284   Shader shader;
 285
 286   if( mImpl->mCustomShader )
 287   {
 288     shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 289                           mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 290                           mImpl->mCustomShader->mHints );
 291
 292     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 293   }
 294   else
 295   {
 296     shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true, IsRoundedCornerRequired() );
 297   }
 298
 299   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 300
 301   mImpl->mRenderer = Renderer::New( geometry, shader );
 302
 303   TextureSet textureSet = TextureSet::New();
 304   mImpl->mRenderer.SetTextures( textureSet );
 305
 306   // Register transform properties
 307   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 308 }
 309
 310 void AnimatedVectorImageVisual::DoSetOnScene(Actor& actor)
 311 {
 312   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 313
 314   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 315   mPlacementActor = actor;
 316
 317   mVectorAnimationTask->SetRenderer( mImpl->mRenderer );
 318
 319   // Add property notification for scaling & size
 320   mScaleNotification = actor.AddPropertyNotification( Actor::Property::WORLD_SCALE, StepCondition( 0.1f, 1.0f ) );
 321   mScaleNotification.NotifySignal().Connect( this, &AnimatedVectorImageVisual::OnScaleNotification );
 322
 323   mSizeNotification = actor.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 3.0f ) );
 324   mSizeNotification.NotifySignal().Connect( this, &AnimatedVectorImageVisual::OnSizeNotification );
 325
 326   DevelActor::VisibilityChangedSignal( actor ).Connect( this, &AnimatedVectorImageVisual::OnControlVisibilityChanged );
 327
 328   Window window = DevelWindow::Get( actor );
 329   if( window )
 330   {
 331     DevelWindow::VisibilityChangedSignal( window ).Connect( this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged );
 332   }
 333
 334   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this );
 335 }
 336
 337 void AnimatedVectorImageVisual::DoSetOffScene( Actor& actor )
 338 {
 339   StopAnimation();
 340   SendAnimationData();
 341
 342   if( mImpl->mRenderer )
 343   {
 344     actor.RemoveRenderer( mImpl->mRenderer );
 345     mRendererAdded = false;
 346   }
 347
 348   // Remove property notification
 349   actor.RemovePropertyNotification( mScaleNotification );
 350   actor.RemovePropertyNotification( mSizeNotification );
 351
 352   DevelActor::VisibilityChangedSignal( actor ).Disconnect( this, &AnimatedVectorImageVisual::OnControlVisibilityChanged );
 353
 354   Window window = DevelWindow::Get( actor );
 355   if( window )
 356   {
 357     DevelWindow::VisibilityChangedSignal( window ).Disconnect( this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged );
 358   }
 359
 360   mPlacementActor.Reset();
 361
 362   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 363   mVisualSize = Vector2::ZERO;
 364   mVisualScale = Vector2::ONE;
 365
 366   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this );
 367 }
 368
 369 void AnimatedVectorImageVisual::OnSetTransform()
 370 {
 371   Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize );
 372
 373   if( IsOnScene() && visualSize != mVisualSize )
 374   {
 375     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this );
 376
 377     mVisualSize = visualSize;
 378
 379     SetVectorImageSize();
 380
 381     if( mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING )
 382     {
 383       mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 384       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 385     }
 386
 387     SendAnimationData();
 388   }
 389 }
 390
 391 void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 392 {
 393   // Check if action is valid for this visual type and perform action if possible
 394   switch( actionId )
 395   {
 396     case DevelAnimatedVectorImageVisual::Action::PLAY:
 397     {
 398       if( IsOnScene() && mVisualSize != Vector2::ZERO )
 399       {
 400         if( mAnimationData.playState != DevelImageVisual::PlayState::PLAYING )
 401         {
 402           mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 403           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 404         }
 405       }
 406       mPlayState = DevelImageVisual::PlayState::PLAYING;
 407       break;
 408     }
 409     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 410     {
 411       if( mAnimationData.playState == DevelImageVisual::PlayState::PLAYING )
 412       {
 413         mAnimationData.playState = DevelImageVisual::PlayState::PAUSED;
 414         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 415       }
 416       mPlayState = DevelImageVisual::PlayState::PAUSED;
 417       break;
 418     }
 419     case DevelAnimatedVectorImageVisual::Action::STOP:
 420     {
 421       if( mAnimationData.playState != DevelImageVisual::PlayState::STOPPED )
 422       {
 423         mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 424         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 425       }
 426       mPlayState = DevelImageVisual::PlayState::STOPPED;
 427       break;
 428     }
 429     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 430     {
 431       int32_t frameNumber;
 432       if( attributes.Get( frameNumber ) )
 433       {
 434         mAnimationData.currentFrame = frameNumber;
 435         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME;
 436       }
 437       break;
 438     }
 439     case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
 440     {
 441       const Property::Map* map = attributes.GetMap();
 442       if( map )
 443       {
 444         DoSetProperties( *map );
 445       }
 446       break;
 447     }
 448   }
 449
 450   TriggerVectorRasterization();
 451 }
 452
 453 void AnimatedVectorImageVisual::OnUploadCompleted()
 454 {
 455   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 456   Actor actor = mPlacementActor.GetHandle();
 457   if( actor && !mRendererAdded )
 458   {
 459     actor.AddRenderer( mImpl->mRenderer );
 460     mRendererAdded = true;
 461
 462     ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 463
 464     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnUploadCompleted: Renderer is added [%p]\n", this );
 465   }
 466 }
 467
 468 void AnimatedVectorImageVisual::OnAnimationFinished()
 469 {
 470   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this );
 471
 472   if( mPlayState != DevelImageVisual::PlayState::STOPPED )
 473   {
 474     mPlayState = DevelImageVisual::PlayState::STOPPED;
 475
 476     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 477
 478     if( mImpl->mEventObserver )
 479     {
 480       mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
 481     }
 482   }
 483
 484   if( mImpl->mRenderer )
 485   {
 486     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 487   }
 488 }
 489
 490 void AnimatedVectorImageVisual::SendAnimationData()
 491 {
 492   if( mAnimationData.resendFlag )
 493   {
 494     mVectorAnimationTask->SetAnimationData( mAnimationData );
 495
 496     if( mImpl->mRenderer )
 497     {
 498       if( mAnimationData.playState == DevelImageVisual::PlayState::PLAYING )
 499       {
 500         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 501       }
 502       else
 503       {
 504         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 505       }
 506     }
 507
 508     mAnimationData.resendFlag = 0;
 509   }
 510 }
 511
 512 void AnimatedVectorImageVisual::SetVectorImageSize()
 513 {
 514   uint32_t width = static_cast< uint32_t >( mVisualSize.width * mVisualScale.width );
 515   uint32_t height = static_cast< uint32_t >( mVisualSize.height * mVisualScale.height );
 516
 517   mAnimationData.width = width;
 518   mAnimationData.height = height;
 519   mAnimationData.resendFlag |= VectorAnimationTask::RESEND_SIZE;
 520 }
 521
 522 void AnimatedVectorImageVisual::StopAnimation()
 523 {
 524   if( mAnimationData.playState != DevelImageVisual::PlayState::STOPPED )
 525   {
 526     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 527     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 528
 529     mPlayState = DevelImageVisual::PlayState::STOPPED;
 530   }
 531 }
 532
 533 void AnimatedVectorImageVisual::TriggerVectorRasterization()
 534 {
 535   if( !mEventCallback && !mCoreShutdown )
 536   {
 537     mEventCallback = MakeCallback( this, &AnimatedVectorImageVisual::OnProcessEvents );
 538     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 539     vectorAnimationManager.RegisterEventCallback( mEventCallback );
 540     Stage::GetCurrent().KeepRendering( 0.0f );  // Trigger event processing
 541   }
 542 }
 543
 544 void AnimatedVectorImageVisual::OnScaleNotification( PropertyNotification& source )
 545 {
 546   Actor actor = mPlacementActor.GetHandle();
 547   if( actor )
 548   {
 549     Vector3 scale = actor.GetProperty< Vector3 >( Actor::Property::WORLD_SCALE );
 550
 551     if(mRedrawInScalingDown || scale.width >= 1.0f || scale.height >= 1.0f)
 552     {
 553       mVisualScale.width = scale.width;
 554       mVisualScale.height = scale.height;
 555
 556       DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnScaleNotification: scale = %f, %f [%p]\n", mVisualScale.width, mVisualScale.height, this );
 557
 558       SetVectorImageSize();
 559       SendAnimationData();
 560
 561       Stage::GetCurrent().KeepRendering( 0.0f );  // Trigger event processing
 562     }
 563   }
 564 }
 565
 566 void AnimatedVectorImageVisual::OnSizeNotification( PropertyNotification& source )
 567 {
 568   Actor actor = mPlacementActor.GetHandle();
 569   if( actor )
 570   {
 571     Vector3 size = actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
 572     mVisualSize.width = size.width;
 573     mVisualSize.height = size.height;
 574
 575     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSizeNotification: size = %f, %f [%p]\n", mVisualSize.width, mVisualSize.height, this );
 576
 577     SetVectorImageSize();
 578     SendAnimationData();
 579
 580     Stage::GetCurrent().KeepRendering( 0.0f );  // Trigger event processing
 581   }
 582 }
 583
 584 void AnimatedVectorImageVisual::OnControlVisibilityChanged( Actor actor, bool visible, DevelActor::VisibilityChange::Type type )
 585 {
 586   if( !visible )
 587   {
 588     StopAnimation();
 589     TriggerVectorRasterization();
 590
 591     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnControlVisibilityChanged: invisibile. Pause animation [%p]\n", this );
 592   }
 593 }
 594
 595 void AnimatedVectorImageVisual::OnWindowVisibilityChanged( Window window, bool visible )
 596 {
 597   if( !visible )
 598   {
 599     StopAnimation();
 600     TriggerVectorRasterization();
 601
 602     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnWindowVisibilityChanged: invisibile. Pause animation [%p]\n", this );
 603   }
 604 }
 605
 606 void AnimatedVectorImageVisual::OnProcessEvents()
 607 {
 608   SendAnimationData();
 609
 610   mEventCallback = nullptr;  // The callback will be deleted in the VectorAnimationManager
 611 }
 612
 613 } // namespace Internal
 614
 615 } // namespace Toolkit
 616
 617 } // namespace Dali