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

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