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