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

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