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