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

   1 /*
   2  * Copyright (c) 2023 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 #include <dali/public-api/math/math-utils.h>
  27 #include <dali/public-api/rendering/decorated-visual-renderer.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  33 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  34 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  35 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  36 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  37 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  38 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  39 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  40
  41 namespace Dali
  42 {
  43 namespace Toolkit
  44 {
  45 namespace Internal
  46 {
  47 namespace
  48 {
  49 const int CUSTOM_PROPERTY_COUNT(1); // pixel area,
  50
  51 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  52
  53 // stop behavior
  54 DALI_ENUM_TO_STRING_TABLE_BEGIN(STOP_BEHAVIOR)
  55   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME)
  56   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME)
  57   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME)
  58 DALI_ENUM_TO_STRING_TABLE_END(STOP_BEHAVIOR)
  59
  60 // looping mode
  61 DALI_ENUM_TO_STRING_TABLE_BEGIN(LOOPING_MODE)
  62   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, RESTART)
  63   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, AUTO_REVERSE)
  64 DALI_ENUM_TO_STRING_TABLE_END(LOOPING_MODE)
  65
  66 #if defined(DEBUG_ENABLED)
  67 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
  68 #endif
  69
  70 } // unnamed namespace
  71
  72 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
  73 {
  74   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl, ImageDimensions{}));
  75   visual->SetProperties(properties);
  76   visual->Initialize();
  77   return visual;
  78 }
  79
  80 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  81 {
  82   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl, size));
  83   visual->Initialize();
  84   return visual;
  85 }
  86
  87 AnimatedVectorImageVisual::AnimatedVectorImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  88 : Visual::Base(factoryCache, Visual::FittingMode::FILL, static_cast<Toolkit::Visual::Type>(Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE)),
  89   mUrl(imageUrl),
  90   mAnimationData(),
  91   mVectorAnimationTask(new VectorAnimationTask(factoryCache)),
  92   mImageVisualShaderFactory(shaderFactory),
  93   mVisualSize(),
  94   mVisualScale(Vector2::ONE),
  95   mDesiredSize(size),
  96   mPlacementActor(),
  97   mPlayState(DevelImageVisual::PlayState::STOPPED),
  98   mEventCallback(nullptr),
  99   mLoadFailed(false),
 100   mRendererAdded(false),
 101   mCoreShutdown(false),
 102   mRedrawInScalingDown(true)
 103 {
 104   // the rasterized image is with pre-multiplied alpha format
 105   mImpl->mFlags |= Visual::Base::Impl::IS_PREMULTIPLIED_ALPHA;
 106
 107   // By default, load a file synchronously
 108   mImpl->mFlags |= Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 109 }
 110
 111 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
 112 {
 113   if(!mCoreShutdown)
 114   {
 115     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 116     vectorAnimationManager.RemoveObserver(*this);
 117
 118     if(mEventCallback)
 119     {
 120       mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback(mEventCallback);
 121       mEventCallback = nullptr;
 122     }
 123
 124     // Finalize animation task and disconnect the signal in the main thread
 125     mVectorAnimationTask->ResourceReadySignal().Disconnect(this, &AnimatedVectorImageVisual::OnResourceReady);
 126     mVectorAnimationTask->Finalize();
 127   }
 128 }
 129
 130 void AnimatedVectorImageVisual::VectorAnimationManagerDestroyed()
 131 {
 132   // Core is shutting down. Don't talk to the plugin any more.
 133   mCoreShutdown = true;
 134 }
 135
 136 void AnimatedVectorImageVisual::GetNaturalSize(Vector2& naturalSize)
 137 {
 138   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 139   {
 140     naturalSize.x = mDesiredSize.GetWidth();
 141     naturalSize.y = mDesiredSize.GetHeight();
 142   }
 143   else if(mVisualSize != Vector2::ZERO)
 144   {
 145     naturalSize = mVisualSize;
 146   }
 147   else
 148   {
 149     if(mLoadFailed && mImpl->mRenderer)
 150     {
 151       // Load failed, use broken image size
 152       auto textureSet = mImpl->mRenderer.GetTextures();
 153       if(textureSet && textureSet.GetTextureCount())
 154       {
 155         auto texture = textureSet.GetTexture(0);
 156         if(texture)
 157         {
 158           naturalSize.x = texture.GetWidth();
 159           naturalSize.y = texture.GetHeight();
 160           return;
 161         }
 162       }
 163     }
 164     else
 165     {
 166       uint32_t width, height;
 167       mVectorAnimationTask->GetDefaultSize(width, height);
 168       naturalSize.x = width;
 169       naturalSize.y = height;
 170     }
 171   }
 172
 173   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::GetNaturalSize: w = %f, h = %f [%p]\n", naturalSize.width, naturalSize.height, this);
 174 }
 175
 176 void AnimatedVectorImageVisual::DoCreatePropertyMap(Property::Map& map) const
 177 {
 178   map.Clear();
 179   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE);
 180   if(mUrl.IsValid())
 181   {
 182     map.Insert(Toolkit::ImageVisual::Property::URL, mUrl.GetUrl());
 183   }
 184   map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, mAnimationData.loopCount);
 185
 186   uint32_t startFrame, endFrame;
 187   mVectorAnimationTask->GetPlayRange(startFrame, endFrame);
 188
 189   Property::Array playRange;
 190   playRange.PushBack(static_cast<int32_t>(startFrame));
 191   playRange.PushBack(static_cast<int32_t>(endFrame));
 192   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange);
 193
 194   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast<int32_t>(mPlayState));
 195   map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetCurrentFrameNumber()));
 196   map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetTotalFrameNumber()));
 197
 198   map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mAnimationData.stopBehavior);
 199   map.Insert(Toolkit::DevelImageVisual::Property::LOOPING_MODE, mAnimationData.loopingMode);
 200   map.Insert(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, mRedrawInScalingDown);
 201
 202   Property::Map layerInfo;
 203   mVectorAnimationTask->GetLayerInfo(layerInfo);
 204   map.Insert(Toolkit::DevelImageVisual::Property::CONTENT_INFO, layerInfo);
 205
 206   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired());
 207   map.Insert(Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth());
 208   map.Insert(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight());
 209 }
 210
 211 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 212 {
 213   // Do nothing
 214 }
 215
 216 void AnimatedVectorImageVisual::EnablePreMultipliedAlpha(bool preMultiplied)
 217 {
 218   // Make always enable pre multiplied alpha whether preMultiplied value is false.
 219   if(!preMultiplied)
 220   {
 221     DALI_LOG_WARNING("Note : AnimatedVectorVisual cannot disable PreMultipliedAlpha\n");
 222   }
 223 }
 224
 225 void AnimatedVectorImageVisual::DoSetProperties(const Property::Map& propertyMap)
 226 {
 227   // url already passed in from constructor
 228   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 229   {
 230     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 231     if(keyValue.first.type == Property::Key::INDEX)
 232     {
 233       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 234     }
 235     else
 236     {
 237       if(keyValue.first == LOOP_COUNT_NAME)
 238       {
 239         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second);
 240       }
 241       else if(keyValue.first == PLAY_RANGE_NAME)
 242       {
 243         DoSetProperty(Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second);
 244       }
 245       else if(keyValue.first == STOP_BEHAVIOR_NAME)
 246       {
 247         DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second);
 248       }
 249       else if(keyValue.first == LOOPING_MODE_NAME)
 250       {
 251         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOPING_MODE, keyValue.second);
 252       }
 253       else if(keyValue.first == REDRAW_IN_SCALING_DOWN_NAME)
 254       {
 255         DoSetProperty(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, keyValue.second);
 256       }
 257       else if(keyValue.first == SYNCHRONOUS_LOADING)
 258       {
 259         DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
 260       }
 261       else if(keyValue.first == IMAGE_DESIRED_WIDTH)
 262       {
 263         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second);
 264       }
 265       else if(keyValue.first == IMAGE_DESIRED_HEIGHT)
 266       {
 267         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second);
 268       }
 269     }
 270   }
 271
 272   TriggerVectorRasterization();
 273 }
 274
 275 void AnimatedVectorImageVisual::DoSetProperty(Property::Index index, const Property::Value& value)
 276 {
 277   switch(index)
 278   {
 279     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 280     {
 281       int32_t loopCount;
 282       if(value.Get(loopCount))
 283       {
 284         mAnimationData.loopCount = loopCount;
 285         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOP_COUNT;
 286       }
 287       break;
 288     }
 289     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 290     {
 291       const Property::Array* array = value.GetArray();
 292       if(array)
 293       {
 294         mAnimationData.playRange = *array;
 295         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE;
 296       }
 297       else if(value.GetType() == Property::STRING)
 298       {
 299         std::string markerName;
 300         if(value.Get(markerName))
 301         {
 302           Property::Array array;
 303           array.Add(markerName);
 304           mAnimationData.playRange = std::move(array);
 305           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE;
 306         }
 307       }
 308       break;
 309     }
 310     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 311     {
 312       int32_t stopBehavior = mAnimationData.stopBehavior;
 313       if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior))
 314       {
 315         mAnimationData.stopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior);
 316         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_STOP_BEHAVIOR;
 317       }
 318       break;
 319     }
 320     case Toolkit::DevelImageVisual::Property::LOOPING_MODE:
 321     {
 322       int32_t loopingMode = mAnimationData.loopingMode;
 323       if(Scripting::GetEnumerationProperty(value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode))
 324       {
 325         mAnimationData.loopingMode = DevelImageVisual::LoopingMode::Type(loopingMode);
 326         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOPING_MODE;
 327       }
 328       break;
 329     }
 330     case Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN:
 331     {
 332       bool redraw;
 333       if(value.Get(redraw))
 334       {
 335         mRedrawInScalingDown = redraw;
 336       }
 337       break;
 338     }
 339     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 340     {
 341       bool sync = false;
 342       if(value.Get(sync))
 343       {
 344         if(sync)
 345         {
 346           mImpl->mFlags |= Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 347         }
 348         else
 349         {
 350           mImpl->mFlags &= ~Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 351         }
 352       }
 353       break;
 354     }
 355     case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
 356     {
 357       int32_t desiredWidth = 0;
 358       if(value.Get(desiredWidth))
 359       {
 360         mDesiredSize.SetWidth(desiredWidth);
 361       }
 362       break;
 363     }
 364
 365     case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
 366     {
 367       int32_t desiredHeight = 0;
 368       if(value.Get(desiredHeight))
 369       {
 370         mDesiredSize.SetHeight(desiredHeight);
 371       }
 372       break;
 373     }
 374   }
 375 }
 376
 377 void AnimatedVectorImageVisual::OnInitialize(void)
 378 {
 379   mVectorAnimationTask->ResourceReadySignal().Connect(this, &AnimatedVectorImageVisual::OnResourceReady);
 380   mVectorAnimationTask->SetAnimationFinishedCallback(new EventThreadCallback(MakeCallback(this, &AnimatedVectorImageVisual::OnAnimationFinished)));
 381
 382   mVectorAnimationTask->RequestLoad(mUrl.GetUrl(), IsSynchronousLoadingRequired());
 383
 384   auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 385   vectorAnimationManager.AddObserver(*this);
 386
 387   Shader shader = GenerateShader();
 388
 389   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 390
 391   mImpl->mRenderer = DecoratedVisualRenderer::New(geometry, shader);
 392   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 393
 394   TextureSet textureSet = TextureSet::New();
 395   mImpl->mRenderer.SetTextures(textureSet);
 396
 397   // Register transform properties
 398   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 399
 400   mVectorAnimationTask->SetRenderer(mImpl->mRenderer);
 401 }
 402
 403 void AnimatedVectorImageVisual::DoSetOnScene(Actor& actor)
 404 {
 405   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 406
 407   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 408   mPlacementActor = actor;
 409
 410   if(mLoadFailed)
 411   {
 412     Vector2 imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 413     mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize, false);
 414     actor.AddRenderer(mImpl->mRenderer);
 415     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 416   }
 417   else
 418   {
 419     // Add property notification for scaling & size
 420     mScaleNotification = actor.AddPropertyNotification(Actor::Property::WORLD_SCALE, StepCondition(0.1f, 1.0f));
 421     mScaleNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnScaleNotification);
 422
 423     mSizeNotification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(3.0f));
 424     mSizeNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnSizeNotification);
 425
 426     DevelActor::VisibilityChangedSignal(actor).Connect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 427
 428     Window window = DevelWindow::Get(actor);
 429     if(window)
 430     {
 431       DevelWindow::VisibilityChangedSignal(window).Connect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 432     }
 433
 434     if(mImpl->mEventObserver)
 435     {
 436       // The visual needs it's size set before it can be rasterized hence request relayout once on stage
 437       mImpl->mEventObserver->RelayoutRequest(*this);
 438     }
 439
 440     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_NEED_RESOURCE_READY;
 441     TriggerVectorRasterization();
 442   }
 443
 444   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this);
 445 }
 446
 447 void AnimatedVectorImageVisual::DoSetOffScene(Actor& actor)
 448 {
 449   StopAnimation();
 450   TriggerVectorRasterization();
 451
 452   if(mImpl->mRenderer)
 453   {
 454     actor.RemoveRenderer(mImpl->mRenderer);
 455     mRendererAdded = false;
 456   }
 457
 458   // Remove property notification
 459   actor.RemovePropertyNotification(mScaleNotification);
 460   actor.RemovePropertyNotification(mSizeNotification);
 461
 462   DevelActor::VisibilityChangedSignal(actor).Disconnect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 463
 464   Window window = DevelWindow::Get(actor);
 465   if(window)
 466   {
 467     DevelWindow::VisibilityChangedSignal(window).Disconnect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 468   }
 469
 470   mPlacementActor.Reset();
 471
 472   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 473   mVisualSize           = Vector2::ZERO;
 474   mVisualScale          = Vector2::ONE;
 475   mAnimationData.width  = 0;
 476   mAnimationData.height = 0;
 477
 478   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this);
 479 }
 480
 481 void AnimatedVectorImageVisual::OnSetTransform()
 482 {
 483   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 484
 485   if(IsOnScene() && visualSize != mVisualSize)
 486   {
 487     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this);
 488
 489     mVisualSize = visualSize;
 490
 491     SetVectorImageSize();
 492
 493     if(mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 494     {
 495       mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 496       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 497     }
 498
 499     TriggerVectorRasterization();
 500   }
 501 }
 502
 503 void AnimatedVectorImageVisual::UpdateShader()
 504 {
 505   if(mImpl->mRenderer)
 506   {
 507     Shader shader = GenerateShader();
 508     mImpl->mRenderer.SetShader(shader);
 509   }
 510 }
 511
 512 void AnimatedVectorImageVisual::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
 513 {
 514   // Check if action is valid for this visual type and perform action if possible
 515   switch(actionId)
 516   {
 517     case DevelAnimatedVectorImageVisual::Action::PLAY:
 518     {
 519       if(IsOnScene() && mVisualSize != Vector2::ZERO)
 520       {
 521         if(mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 522         {
 523           mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 524           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 525         }
 526       }
 527       mPlayState = DevelImageVisual::PlayState::PLAYING;
 528       break;
 529     }
 530     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 531     {
 532       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 533       {
 534         mAnimationData.playState = DevelImageVisual::PlayState::PAUSED;
 535         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 536       }
 537       mPlayState = DevelImageVisual::PlayState::PAUSED;
 538       break;
 539     }
 540     case DevelAnimatedVectorImageVisual::Action::STOP:
 541     {
 542       if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 543       {
 544         mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 545         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 546       }
 547       mPlayState = DevelImageVisual::PlayState::STOPPED;
 548       break;
 549     }
 550     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 551     {
 552       int32_t frameNumber;
 553       if(attributes.Get(frameNumber))
 554       {
 555         mAnimationData.currentFrame = frameNumber;
 556         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME;
 557       }
 558       break;
 559     }
 560   }
 561
 562   TriggerVectorRasterization();
 563 }
 564
 565 void AnimatedVectorImageVisual::OnDoActionExtension(const Property::Index actionId, Dali::Any attributes)
 566 {
 567   switch(actionId)
 568   {
 569     case DevelAnimatedVectorImageVisual::Action::SET_DYNAMIC_PROPERTY:
 570     {
 571       DevelAnimatedVectorImageVisual::DynamicPropertyInfo info = AnyCast<DevelAnimatedVectorImageVisual::DynamicPropertyInfo>(attributes);
 572       mAnimationData.dynamicProperties.push_back(info);
 573       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_DYNAMIC_PROPERTY;
 574       break;
 575     }
 576   }
 577
 578   TriggerVectorRasterization();
 579 }
 580
 581 void AnimatedVectorImageVisual::OnResourceReady(VectorAnimationTask::ResourceStatus status)
 582 {
 583   if(status == VectorAnimationTask::ResourceStatus::LOADED)
 584   {
 585     if(mImpl->mEventObserver)
 586     {
 587       mImpl->mEventObserver->RelayoutRequest(*this);
 588     }
 589   }
 590   else
 591   {
 592     mLoadFailed = status == VectorAnimationTask::ResourceStatus::FAILED ? true : false;
 593
 594     // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 595     Actor actor = mPlacementActor.GetHandle();
 596     if(actor && !mRendererAdded)
 597     {
 598       if(!mLoadFailed)
 599       {
 600         actor.AddRenderer(mImpl->mRenderer);
 601         ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 602       }
 603       else
 604       {
 605         Vector2 imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 606         mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize, false);
 607         actor.AddRenderer(mImpl->mRenderer);
 608         ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 609       }
 610
 611       mRendererAdded = true;
 612     }
 613   }
 614
 615   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "status = %d [%p]\n", status, this);
 616 }
 617
 618 void AnimatedVectorImageVisual::OnAnimationFinished()
 619 {
 620   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this);
 621
 622   if(mPlayState != DevelImageVisual::PlayState::STOPPED)
 623   {
 624     mPlayState = DevelImageVisual::PlayState::STOPPED;
 625
 626     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 627
 628     if(mImpl->mEventObserver)
 629     {
 630       mImpl->mEventObserver->NotifyVisualEvent(*this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED);
 631     }
 632   }
 633
 634   if(mImpl->mRenderer)
 635   {
 636     mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 637   }
 638 }
 639
 640 void AnimatedVectorImageVisual::SendAnimationData()
 641 {
 642   if(mAnimationData.resendFlag)
 643   {
 644     mVectorAnimationTask->SetAnimationData(mAnimationData);
 645
 646     if(mImpl->mRenderer)
 647     {
 648       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 649       {
 650         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY);
 651       }
 652       else
 653       {
 654         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 655       }
 656     }
 657
 658     mAnimationData.resendFlag = 0;
 659   }
 660 }
 661
 662 void AnimatedVectorImageVisual::SetVectorImageSize()
 663 {
 664   uint32_t width, height;
 665   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 666   {
 667     width  = mDesiredSize.GetWidth();
 668     height = mDesiredSize.GetHeight();
 669   }
 670   else
 671   {
 672     width  = static_cast<uint32_t>(mVisualSize.width * mVisualScale.width);
 673     height = static_cast<uint32_t>(mVisualSize.height * mVisualScale.height);
 674   }
 675
 676   if(mAnimationData.width != width || mAnimationData.height != height)
 677   {
 678     mAnimationData.width  = width;
 679     mAnimationData.height = height;
 680     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_SIZE;
 681   }
 682 }
 683
 684 void AnimatedVectorImageVisual::StopAnimation()
 685 {
 686   if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 687   {
 688     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 689     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 690
 691     mPlayState = DevelImageVisual::PlayState::STOPPED;
 692   }
 693 }
 694
 695 void AnimatedVectorImageVisual::TriggerVectorRasterization()
 696 {
 697   if(!mEventCallback && !mCoreShutdown)
 698   {
 699     mEventCallback               = MakeCallback(this, &AnimatedVectorImageVisual::OnProcessEvents);
 700     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 701     vectorAnimationManager.RegisterEventCallback(mEventCallback);
 702     Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 703   }
 704 }
 705
 706 void AnimatedVectorImageVisual::OnScaleNotification(PropertyNotification& source)
 707 {
 708   Actor actor = mPlacementActor.GetHandle();
 709   if(actor)
 710   {
 711     Vector3 scale = actor.GetProperty<Vector3>(Actor::Property::WORLD_SCALE);
 712
 713     if((!Dali::Equals(mVisualScale.width, scale.width) || !Dali::Equals(mVisualScale.height, scale.height)) && (mRedrawInScalingDown || scale.width >= 1.0f || scale.height >= 1.0f))
 714     {
 715       mVisualScale.width  = scale.width;
 716       mVisualScale.height = scale.height;
 717
 718       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnScaleNotification: scale = %f, %f [%p]\n", mVisualScale.width, mVisualScale.height, this);
 719
 720       SetVectorImageSize();
 721       SendAnimationData();
 722
 723       Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 724     }
 725   }
 726 }
 727
 728 void AnimatedVectorImageVisual::OnSizeNotification(PropertyNotification& source)
 729 {
 730   Actor actor = mPlacementActor.GetHandle();
 731   if(actor)
 732   {
 733     Vector3 size = actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE);
 734
 735     if(!Dali::Equals(mVisualSize.width, size.width) || !Dali::Equals(mVisualSize.height, size.height))
 736     {
 737       mVisualSize.width  = size.width;
 738       mVisualSize.height = size.height;
 739
 740       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSizeNotification: size = %f, %f [%p]\n", mVisualSize.width, mVisualSize.height, this);
 741
 742       SetVectorImageSize();
 743       SendAnimationData();
 744
 745       Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 746     }
 747   }
 748 }
 749
 750 void AnimatedVectorImageVisual::OnControlVisibilityChanged(Actor actor, bool visible, DevelActor::VisibilityChange::Type type)
 751 {
 752   if(!visible)
 753   {
 754     StopAnimation();
 755     TriggerVectorRasterization();
 756
 757     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnControlVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 758   }
 759 }
 760
 761 void AnimatedVectorImageVisual::OnWindowVisibilityChanged(Window window, bool visible)
 762 {
 763   if(!visible)
 764   {
 765     StopAnimation();
 766     TriggerVectorRasterization();
 767
 768     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnWindowVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 769   }
 770 }
 771
 772 void AnimatedVectorImageVisual::OnProcessEvents()
 773 {
 774   SendAnimationData();
 775
 776   mEventCallback = nullptr; // The callback will be deleted in the VectorAnimationManager
 777 }
 778
 779 Shader AnimatedVectorImageVisual::GenerateShader() const
 780 {
 781   Shader shader;
 782   if(mImpl->mCustomShader)
 783   {
 784     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 785                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 786                          mImpl->mCustomShader->mHints);
 787
 788     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 789   }
 790   else
 791   {
 792     shader = mImageVisualShaderFactory.GetShader(
 793       mFactoryCache,
 794       ImageVisualShaderFeature::FeatureBuilder()
 795         .EnableRoundedCorner(IsRoundedCornerRequired())
 796         .EnableBorderline(IsBorderlineRequired()));
 797   }
 798   return shader;
 799 }
 800
 801 } // namespace Internal
 802
 803 } // namespace Toolkit
 804
 805 } // namespace Dali