Add text selection popup style
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / animated-image / animated-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 "animated-image-visual.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/devel-api/adaptor-framework/image-loading.h>
23 #include <dali/integration-api/debug.h>
24 #include <memory>
25
26 // INTERNAL INCLUDES
27 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
28 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
29 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
30 #include <dali-toolkit/internal/visuals/animated-image/fixed-image-cache.h>
31 #include <dali-toolkit/internal/visuals/animated-image/rolling-animated-image-cache.h>
32 #include <dali-toolkit/internal/visuals/animated-image/rolling-image-cache.h>
33 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
34 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
35 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
36 #include <dali-toolkit/internal/visuals/visual-factory-impl.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(3); // ltr, wrap, pixel area,
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 // wrap modes
59 DALI_ENUM_TO_STRING_TABLE_BEGIN(WRAP_MODE)
60   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, DEFAULT)
61   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, CLAMP_TO_EDGE)
62   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, REPEAT)
63   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::WrapMode, MIRRORED_REPEAT)
64 DALI_ENUM_TO_STRING_TABLE_END(WRAP_MODE)
65
66 // load policies
67 DALI_ENUM_TO_STRING_TABLE_BEGIN(LOAD_POLICY)
68   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, IMMEDIATE)
69   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::LoadPolicy, ATTACHED)
70 DALI_ENUM_TO_STRING_TABLE_END(LOAD_POLICY)
71
72 // release policies
73 DALI_ENUM_TO_STRING_TABLE_BEGIN(RELEASE_POLICY)
74   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DETACHED)
75   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, DESTROYED)
76   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::ImageVisual::ReleasePolicy, NEVER)
77 DALI_ENUM_TO_STRING_TABLE_END(RELEASE_POLICY)
78
79 static constexpr uint32_t SINGLE_IMAGE_COUNT = 1u;
80 static constexpr uint32_t FIRST_FRAME_INDEX  = 0u;
81 static constexpr uint16_t MINIMUM_CACHESIZE  = 1;
82 static constexpr Vector4  FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
83 static constexpr auto     LOOP_FOREVER = -1;
84 static constexpr auto     FIRST_LOOP   = 0u;
85
86 #if defined(DEBUG_ENABLED)
87 Debug::Filter* gAnimImgLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_ANIMATED_IMAGE");
88 #endif
89 } // namespace
90
91 /**
92  * Multi-image  Flow of execution
93  *
94  *   | New
95  *   |   DoSetProperties()
96  *   |   OnInitialize()
97  *   |     CreateImageCache()
98  *   |
99  *   | DoSetOnScene()
100  *   |   PrepareTextureSet()
101  *   |     cache->FirstFrame()
102  *   |
103  *   | FrameReady(textureSet)
104  *   |   StartFirstFrame:
105  *   |     actor.AddRenderer
106  *   |     start timer
107  *   |   mRenderer.SetTextures(textureSet)
108  *   |
109  *   | Timer ticks
110  *   |   DisplayNextFrame()
111  *   |     if front frame is ready,
112  *   |       mRenderer.SetTextures( front frame's texture )
113  *   |     else
114  *   |       Waiting for frame ready.
115  *   |
116  *   | FrameReady(textureSet)
117  *   |   mRenderer.SetTextures(textureSet)
118  *   V
119  *  Time
120  */
121
122 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
123 {
124   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory));
125   visual->InitializeAnimatedImage(imageUrl);
126   visual->SetProperties(properties);
127
128   visual->Initialize();
129
130   return visual;
131 }
132
133 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const Property::Array& imageUrls, const Property::Map& properties)
134 {
135   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory));
136   visual->mImageUrls = new ImageCache::UrlList();
137   visual->mImageUrls->reserve(imageUrls.Count());
138
139   for(unsigned int i = 0; i < imageUrls.Count(); ++i)
140   {
141     ImageCache::UrlStore urlStore;
142     urlStore.mTextureId = TextureManager::INVALID_TEXTURE_ID;
143     urlStore.mUrl       = imageUrls[i].Get<std::string>();
144     visual->mImageUrls->push_back(urlStore);
145   }
146   visual->mFrameCount = imageUrls.Count();
147   visual->SetProperties(properties);
148
149   visual->Initialize();
150
151   return visual;
152 }
153
154 AnimatedImageVisualPtr AnimatedImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
155 {
156   AnimatedImageVisualPtr visual(new AnimatedImageVisual(factoryCache, shaderFactory));
157   visual->InitializeAnimatedImage(imageUrl);
158
159   visual->Initialize();
160
161   return visual;
162 }
163
164 void AnimatedImageVisual::InitializeAnimatedImage(const VisualUrl& imageUrl)
165 {
166   mImageUrl = imageUrl;
167   mAnimatedImageLoading = AnimatedImageLoading::New(imageUrl.GetUrl(), imageUrl.IsLocalResource());
168 }
169
170 void AnimatedImageVisual::CreateImageCache()
171 {
172   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::CreateImageCache()  batchSize:%d  cacheSize:%d\n", mBatchSize, mCacheSize);
173
174   TextureManager& textureManager = mFactoryCache.GetTextureManager();
175
176   if(mAnimatedImageLoading)
177   {
178     mImageCache = new RollingAnimatedImageCache(textureManager, mAnimatedImageLoading, mMaskingData, *this, mCacheSize, mBatchSize, IsSynchronousLoadingRequired());
179   }
180   else if(mImageUrls)
181   {
182     // Ensure the batch size and cache size are no bigger than the number of URLs,
183     // and that the cache is at least as big as the batch size.
184     uint16_t numUrls   = mImageUrls->size();
185     uint16_t batchSize = std::max(std::min(mBatchSize, numUrls), MINIMUM_CACHESIZE);
186     uint16_t cacheSize = std::max(std::min(std::max(batchSize, mCacheSize), numUrls), MINIMUM_CACHESIZE);
187     if(cacheSize < numUrls)
188     {
189       mImageCache = new RollingImageCache(textureManager, *mImageUrls, mMaskingData, *this, cacheSize, batchSize, mFrameDelay);
190     }
191     else
192     {
193       mImageCache = new FixedImageCache(textureManager, *mImageUrls, mMaskingData, *this, batchSize, mFrameDelay);
194     }
195   }
196
197   if(!mImageCache)
198   {
199     DALI_LOG_ERROR("mImageCache is null\n");
200   }
201 }
202
203 AnimatedImageVisual::AnimatedImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory)
204 : Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::ANIMATED_IMAGE),
205   mFrameDelayTimer(),
206   mPlacementActor(),
207   mImageVisualShaderFactory(shaderFactory),
208   mPixelArea(FULL_TEXTURE_RECT),
209   mImageUrl(),
210   mAnimatedImageLoading(),
211   mFrameIndexForJumpTo(0),
212   mCurrentFrameIndex(FIRST_FRAME_INDEX),
213   mImageUrls(NULL),
214   mImageCache(NULL),
215   mCacheSize(2),
216   mBatchSize(2),
217   mFrameDelay(100),
218   mLoopCount(LOOP_FOREVER),
219   mCurrentLoopIndex(FIRST_LOOP),
220   mLoadPolicy(Toolkit::ImageVisual::LoadPolicy::ATTACHED),
221   mReleasePolicy(Toolkit::ImageVisual::ReleasePolicy::DETACHED),
222   mMaskingData(),
223   mFrameCount(0),
224   mImageSize(),
225   mActionStatus(DevelAnimatedImageVisual::Action::PLAY),
226   mWrapModeU(WrapMode::DEFAULT),
227   mWrapModeV(WrapMode::DEFAULT),
228   mStopBehavior(DevelImageVisual::StopBehavior::CURRENT_FRAME),
229   mStartFirstFrame(false),
230   mIsJumpTo(false)
231 {
232 }
233
234 AnimatedImageVisual::~AnimatedImageVisual()
235 {
236   // AnimatedImageVisual destroyed so remove texture unless ReleasePolicy is set to never release
237   // If this is animated image, clear cache. Else if this is single frame image, this is affected be release policy.
238   if(mFrameCount > SINGLE_IMAGE_COUNT || mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER)
239   {
240     mImageCache->ClearCache();
241   }
242   delete mImageCache;
243   delete mImageUrls;
244 }
245
246 void AnimatedImageVisual::GetNaturalSize(Vector2& naturalSize)
247 {
248   if(mImageSize.GetWidth() == 0 && mImageSize.GetHeight() == 0)
249   {
250     if(mMaskingData && mMaskingData->mAlphaMaskUrl.IsValid() &&
251        mMaskingData->mCropToMask)
252     {
253       ImageDimensions dimensions = Dali::GetClosestImageSize(mMaskingData->mAlphaMaskUrl.GetUrl());
254       if(dimensions != ImageDimensions(0, 0))
255       {
256         mImageSize = dimensions;
257         naturalSize.x = dimensions.GetWidth();
258         naturalSize.y = dimensions.GetHeight();
259         return;
260       }
261     }
262
263     if(mImageUrl.IsValid())
264     {
265       mImageSize = mAnimatedImageLoading.GetImageSize();
266     }
267     else if(mImageUrls && mImageUrls->size() > 0)
268     {
269       mImageSize = Dali::GetClosestImageSize((*mImageUrls)[0].mUrl);
270     }
271   }
272
273   naturalSize.width  = mImageSize.GetWidth();
274   naturalSize.height = mImageSize.GetHeight();
275 }
276
277 void AnimatedImageVisual::DoCreatePropertyMap(Property::Map& map) const
278 {
279   map.Clear();
280
281   bool sync = IsSynchronousLoadingRequired();
282   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, sync);
283
284   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::ANIMATED_IMAGE);
285
286   if(mImageUrl.IsValid())
287   {
288     map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl());
289   }
290   if(mImageUrls != NULL && !mImageUrls->empty())
291   {
292     Property::Array urls;
293     for(unsigned int i = 0; i < mImageUrls->size(); ++i)
294     {
295       urls.Add((*mImageUrls)[i].mUrl);
296     }
297     Property::Value value(const_cast<Property::Array&>(urls));
298     map.Insert(Toolkit::ImageVisual::Property::URL, value);
299   }
300
301   map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea);
302   map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU);
303   map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV);
304
305   map.Insert(Toolkit::ImageVisual::Property::BATCH_SIZE, static_cast<int>(mBatchSize));
306   map.Insert(Toolkit::ImageVisual::Property::CACHE_SIZE, static_cast<int>(mCacheSize));
307   map.Insert(Toolkit::ImageVisual::Property::FRAME_DELAY, static_cast<int>(mFrameDelay));
308   map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast<int>(mLoopCount));
309   map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, (mImageCache) ? static_cast<int32_t>(mImageCache->GetCurrentFrameIndex()) : -1);
310   map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, (mImageCache) ? static_cast<int32_t>((mAnimatedImageLoading) ? mAnimatedImageLoading.GetImageCount() : 
311                                                                                                                                      mImageCache->GetTotalFrameCount()) : -1);
312
313   map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mStopBehavior);
314
315   if(mMaskingData != nullptr)
316   {
317     map.Insert(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, mMaskingData->mAlphaMaskUrl.GetUrl());
318     map.Insert(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, mMaskingData->mContentScaleFactor);
319     map.Insert(Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask);
320   }
321
322   map.Insert(Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy);
323   map.Insert(Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy);
324 }
325
326 void AnimatedImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const
327 {
328   // Do nothing
329 }
330
331 void AnimatedImageVisual::OnDoAction(const Dali::Property::Index actionId, const Dali::Property::Value& attributes)
332 {
333   // Make not set any action when the resource status is already failed.
334   if(mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED)
335   {
336     return;
337   }
338
339   // Check if action is valid for this visual type and perform action if possible
340   switch(actionId)
341   {
342     case DevelAnimatedImageVisual::Action::PAUSE:
343     {
344       // Pause will be executed on next timer tick
345       mActionStatus = DevelAnimatedImageVisual::Action::PAUSE;
346       break;
347     }
348     case DevelAnimatedImageVisual::Action::PLAY:
349     {
350       if(mFrameDelayTimer && IsOnScene() && mActionStatus != DevelAnimatedImageVisual::Action::PLAY)
351       {
352         mFrameDelayTimer.Start();
353       }
354       mActionStatus = DevelAnimatedImageVisual::Action::PLAY;
355       break;
356     }
357     case DevelAnimatedImageVisual::Action::STOP:
358     {
359       // STOP reset functionality will actually be done in a future change
360       // Stop will be executed on next timer tick
361       mActionStatus = DevelAnimatedImageVisual::Action::STOP;
362       mCurrentLoopIndex = FIRST_LOOP;
363       if(IsOnScene())
364       {
365         DisplayNextFrame();
366       }
367       break;
368     }
369     case DevelAnimatedImageVisual::Action::JUMP_TO:
370     {
371       int32_t frameNumber;
372       if(attributes.Get(frameNumber))
373       {
374         if(frameNumber < 0 || frameNumber >= static_cast<int32_t>(mFrameCount))
375         {
376           DALI_LOG_ERROR("Invalid frame index used.\n");
377         }
378         else
379         {
380           mIsJumpTo            = true;
381           mFrameIndexForJumpTo = frameNumber;
382           if(IsOnScene())
383           {
384             DisplayNextFrame();
385           }
386         }
387       }
388       break;
389     }
390   }
391 }
392
393 void AnimatedImageVisual::DoSetProperties(const Property::Map& propertyMap)
394 {
395   // url[s] already passed in from constructor
396   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
397   {
398     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
399     if(keyValue.first.type == Property::Key::INDEX)
400     {
401       DoSetProperty(keyValue.first.indexKey, keyValue.second);
402     }
403     else
404     {
405       if(keyValue.first == PIXEL_AREA_UNIFORM_NAME)
406       {
407         DoSetProperty(Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second);
408       }
409       else if(keyValue.first == IMAGE_WRAP_MODE_U)
410       {
411         DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second);
412       }
413       else if(keyValue.first == IMAGE_WRAP_MODE_V)
414       {
415         DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second);
416       }
417       else if(keyValue.first == BATCH_SIZE_NAME)
418       {
419         DoSetProperty(Toolkit::ImageVisual::Property::BATCH_SIZE, keyValue.second);
420       }
421       else if(keyValue.first == CACHE_SIZE_NAME)
422       {
423         DoSetProperty(Toolkit::ImageVisual::Property::CACHE_SIZE, keyValue.second);
424       }
425       else if(keyValue.first == FRAME_DELAY_NAME)
426       {
427         DoSetProperty(Toolkit::ImageVisual::Property::FRAME_DELAY, keyValue.second);
428       }
429       else if(keyValue.first == LOOP_COUNT_NAME)
430       {
431         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second);
432       }
433       else if(keyValue.first == STOP_BEHAVIOR_NAME)
434       {
435         DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second);
436       }
437       else if(keyValue.first == ALPHA_MASK_URL)
438       {
439         DoSetProperty(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second);
440       }
441       else if(keyValue.first == MASK_CONTENT_SCALE_NAME)
442       {
443         DoSetProperty(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second);
444       }
445       else if(keyValue.first == CROP_TO_MASK_NAME)
446       {
447         DoSetProperty(Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second);
448       }
449       else if(keyValue.first == LOAD_POLICY_NAME)
450       {
451         DoSetProperty(Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second);
452       }
453       else if(keyValue.first == RELEASE_POLICY_NAME)
454       {
455         DoSetProperty(Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second);
456       }
457       else if(keyValue.first == SYNCHRONOUS_LOADING)
458       {
459         DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
460       }
461     }
462   }
463   // Load image immediately if LOAD_POLICY requires it
464   if(mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::IMMEDIATE)
465   {
466     PrepareTextureSet();
467   }
468 }
469
470 void AnimatedImageVisual::DoSetProperty(Property::Index        index,
471                                         const Property::Value& value)
472 {
473   switch(index)
474   {
475     case Toolkit::ImageVisual::Property::PIXEL_AREA:
476     {
477       value.Get(mPixelArea);
478       break;
479     }
480     case Toolkit::ImageVisual::Property::WRAP_MODE_U:
481     {
482       int wrapMode = 0;
483       if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode))
484       {
485         mWrapModeU = Dali::WrapMode::Type(wrapMode);
486       }
487       else
488       {
489         mWrapModeU = Dali::WrapMode::Type::DEFAULT;
490       }
491       break;
492     }
493     case Toolkit::ImageVisual::Property::WRAP_MODE_V:
494     {
495       int wrapMode = 0;
496       if(Scripting::GetEnumerationProperty(value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode))
497       {
498         mWrapModeV = Dali::WrapMode::Type(wrapMode);
499       }
500       else
501       {
502         mWrapModeV = Dali::WrapMode::Type::DEFAULT;
503       }
504       break;
505     }
506
507     case Toolkit::ImageVisual::Property::BATCH_SIZE:
508     {
509       int batchSize;
510       if(value.Get(batchSize))
511       {
512         if(batchSize < 2)
513         {
514           DALI_LOG_ERROR("The minimum value of batch size is 2.");
515         }
516         else
517         {
518           mBatchSize = batchSize;
519         }
520       }
521       break;
522     }
523
524     case Toolkit::ImageVisual::Property::CACHE_SIZE:
525     {
526       int cacheSize;
527       if(value.Get(cacheSize))
528       {
529         if(cacheSize < 2)
530         {
531           DALI_LOG_ERROR("The minimum value of cache size is 2.");
532         }
533         else
534         {
535           mCacheSize = cacheSize;
536         }
537       }
538       break;
539     }
540
541     case Toolkit::ImageVisual::Property::FRAME_DELAY:
542     {
543       int frameDelay;
544       if(value.Get(frameDelay))
545       {
546         mFrameDelay = frameDelay;
547         if(mImageCache)
548         {
549           mImageCache->SetInterval(static_cast<uint32_t>(mFrameDelay));
550         }
551       }
552       break;
553     }
554
555     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
556     {
557       int loopCount;
558       if(value.Get(loopCount))
559       {
560         mLoopCount = loopCount;
561       }
562       break;
563     }
564
565     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
566     {
567       int32_t stopBehavior = mStopBehavior;
568       if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior))
569       {
570         mStopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior);
571       }
572       break;
573     }
574
575     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
576     {
577       bool sync = false;
578       value.Get(sync);
579       if(sync)
580       {
581         mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
582       }
583       else
584       {
585         mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
586       }
587       break;
588     }
589
590     case Toolkit::ImageVisual::Property::ALPHA_MASK_URL:
591     {
592       std::string alphaUrl = "";
593       if(value.Get(alphaUrl))
594       {
595         AllocateMaskData();
596         mMaskingData->mAlphaMaskUrl = alphaUrl;
597       }
598       break;
599     }
600
601     case Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE:
602     {
603       float scale = 1.0f;
604       if(value.Get(scale))
605       {
606         AllocateMaskData();
607         mMaskingData->mContentScaleFactor = scale;
608       }
609       break;
610     }
611
612     case Toolkit::ImageVisual::Property::CROP_TO_MASK:
613     {
614       bool crop = false;
615       if(value.Get(crop))
616       {
617         AllocateMaskData();
618         mMaskingData->mCropToMask = crop;
619       }
620       break;
621     }
622
623     case Toolkit::ImageVisual::Property::RELEASE_POLICY:
624     {
625       int releasePolicy = 0;
626       Scripting::GetEnumerationProperty(value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy);
627       mReleasePolicy = Toolkit::ImageVisual::ReleasePolicy::Type(releasePolicy);
628       break;
629     }
630
631     case Toolkit::ImageVisual::Property::LOAD_POLICY:
632     {
633       int loadPolicy = 0;
634       Scripting::GetEnumerationProperty(value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy);
635       mLoadPolicy = Toolkit::ImageVisual::LoadPolicy::Type(loadPolicy);
636       break;
637     }
638   }
639 }
640
641 void AnimatedImageVisual::DoSetOnScene(Actor& actor)
642 {
643   mStartFirstFrame      = true;
644   mPlacementActor       = actor;
645   PrepareTextureSet();
646 }
647
648 void AnimatedImageVisual::DoSetOffScene(Actor& actor)
649 {
650   DALI_ASSERT_DEBUG((bool)mImpl->mRenderer && "There should always be a renderer whilst on stage");
651
652   if(mFrameDelayTimer)
653   {
654     mFrameDelayTimer.Stop();
655     mFrameDelayTimer.Reset();
656   }
657
658   actor.RemoveRenderer(mImpl->mRenderer);
659   if(mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED)
660   {
661     mImageCache->ClearCache(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
662     mImpl->mResourceStatus = Toolkit::Visual::ResourceStatus::PREPARING;
663
664     TextureSet textureSet = TextureSet::New();
665     mImpl->mRenderer.SetTextures(textureSet);
666   }
667
668   mPlacementActor.Reset();
669   mStartFirstFrame = false;
670   mCurrentFrameIndex = FIRST_FRAME_INDEX;
671   mCurrentLoopIndex = FIRST_LOOP;
672 }
673
674 void AnimatedImageVisual::OnSetTransform()
675 {
676   if(mImpl->mRenderer)
677   {
678     mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
679   }
680 }
681
682 void AnimatedImageVisual::UpdateShader()
683 {
684   if(mImpl->mRenderer)
685   {
686     Shader shader = GenerateShader();
687     mImpl->mRenderer.SetShader(shader);
688   }
689 }
690
691 Shader AnimatedImageVisual::GenerateShader() const
692 {
693   bool   defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
694   Shader shader;
695   shader = mImageVisualShaderFactory.GetShader(
696     mFactoryCache,
697     ImageVisualShaderFeature::FeatureBuilder()
698       .ApplyDefaultTextureWrapMode(defaultWrapMode)
699       .EnableRoundedCorner(IsRoundedCornerRequired())
700       .EnableBorderline(IsBorderlineRequired()));
701   return shader;
702 }
703
704 void AnimatedImageVisual::OnInitialize()
705 {
706   CreateImageCache();
707
708   bool   defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
709   Shader shader          = GenerateShader();
710
711   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
712
713   mImpl->mRenderer = VisualRenderer::New(geometry, shader);
714   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
715
716   // Register transform properties
717   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
718
719   if(!defaultWrapMode) // custom wrap mode
720   {
721     Vector2 wrapMode(mWrapModeU - WrapMode::CLAMP_TO_EDGE, mWrapModeV - WrapMode::CLAMP_TO_EDGE);
722     wrapMode.Clamp(Vector2::ZERO, Vector2(2.f, 2.f));
723     mImpl->mRenderer.RegisterProperty(WRAP_MODE_UNIFORM_NAME, wrapMode);
724   }
725
726   if(mPixelArea != FULL_TEXTURE_RECT)
727   {
728     mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea);
729   }
730 }
731
732 void AnimatedImageVisual::StartFirstFrame(TextureSet& textureSet, uint32_t firstInterval)
733 {
734   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::StartFirstFrame()\n");
735
736   mStartFirstFrame = false;
737   if(mImpl->mRenderer)
738   {
739     mImpl->mRenderer.SetTextures(textureSet);
740
741     Actor actor = mPlacementActor.GetHandle();
742     if(actor)
743     {
744       actor.AddRenderer(mImpl->mRenderer);
745       mPlacementActor.Reset();
746     }
747   }
748
749   if(mImpl->mResourceStatus != Toolkit::Visual::ResourceStatus::FAILED)
750   {
751     if(mFrameCount > SINGLE_IMAGE_COUNT)
752     {
753       mFrameDelayTimer = Timer::New(firstInterval);
754       mFrameDelayTimer.TickSignal().Connect(this, &AnimatedImageVisual::DisplayNextFrame);
755       mFrameDelayTimer.Start();
756     }
757
758     DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::READY)\n");
759     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
760   }
761
762   mCurrentFrameIndex = FIRST_FRAME_INDEX;
763 }
764
765 void AnimatedImageVisual::PrepareTextureSet()
766 {
767   TextureSet textureSet;
768   if(mImageCache)
769   {
770     textureSet = mImageCache->FirstFrame();
771   }
772
773   // Check whether synchronous loading is true or false for the first frame.
774   if(textureSet)
775   {
776     SetImageSize(textureSet);
777   }
778 }
779
780 void AnimatedImageVisual::SetImageSize(TextureSet& textureSet)
781 {
782   if(textureSet)
783   {
784     Texture texture = textureSet.GetTexture(0);
785     if(texture)
786     {
787       mImageSize.SetWidth(texture.GetWidth());
788       mImageSize.SetHeight(texture.GetHeight());
789     }
790   }
791 }
792
793 void AnimatedImageVisual::FrameReady(TextureSet textureSet, uint32_t interval)
794 {
795   // When image visual requested to load new frame to mImageCache and it is failed.
796   if(!mImageCache || !textureSet)
797   {
798     textureSet = SetLoadingFailed();
799   }
800   SetImageSize(textureSet);
801
802   if(mStartFirstFrame)
803   {
804     mFrameCount = mImageCache->GetTotalFrameCount();
805     StartFirstFrame(textureSet, interval);
806   }
807   else
808   {
809     if(mImpl->mRenderer)
810     {
811       if(mFrameDelayTimer && interval > 0u)
812       {
813         mFrameDelayTimer.SetInterval(interval);
814       }
815       mImpl->mRenderer.SetTextures(textureSet);
816     }
817   }
818 }
819
820 bool AnimatedImageVisual::DisplayNextFrame()
821 {
822   TextureSet textureSet;
823   bool       continueTimer = false;
824
825   if(mImageCache)
826   {
827     uint32_t frameIndex = mImageCache->GetCurrentFrameIndex();
828
829     if(mIsJumpTo)
830     {
831       mIsJumpTo  = false;
832       frameIndex = mFrameIndexForJumpTo;
833     }
834     else if(mActionStatus == DevelAnimatedImageVisual::Action::PAUSE)
835     {
836       return false;
837     }
838     else if(mActionStatus == DevelAnimatedImageVisual::Action::STOP)
839     {
840       mCurrentLoopIndex = FIRST_LOOP;
841       if(mStopBehavior == DevelImageVisual::StopBehavior::FIRST_FRAME)
842       {
843         frameIndex = FIRST_FRAME_INDEX;
844       }
845       else if(mStopBehavior == DevelImageVisual::StopBehavior::LAST_FRAME)
846       {
847         frameIndex = mFrameCount - 1;
848       }
849       else
850       {
851         return false; // Do not draw already rendered scene twice.
852       }
853     }
854     else
855     {
856       if(mFrameCount > SINGLE_IMAGE_COUNT)
857       {
858         frameIndex++;
859         if(frameIndex >= mFrameCount)
860         {
861           frameIndex = FIRST_FRAME_INDEX;
862           ++mCurrentLoopIndex;
863         }
864
865         if(mLoopCount >= 0 && mCurrentLoopIndex >= mLoopCount)
866         {
867           // This will stop timer
868           mActionStatus = DevelAnimatedImageVisual::Action::STOP;
869           return DisplayNextFrame();
870         }
871       }
872     }
873
874     DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "AnimatedImageVisual::DisplayNextFrame(this:%p) CurrentFrameIndex:%d\n", this, frameIndex);
875
876     textureSet = mImageCache->Frame(frameIndex);
877
878     if(textureSet)
879     {
880       SetImageSize(textureSet);
881       if(mImpl->mRenderer)
882       {
883         mImpl->mRenderer.SetTextures(textureSet);
884       }
885       mFrameDelayTimer.SetInterval(mImageCache->GetFrameInterval(frameIndex));
886     }
887
888     mCurrentFrameIndex = frameIndex;
889     continueTimer      = (mActionStatus == DevelAnimatedImageVisual::Action::PLAY && textureSet) ? true : false;
890   }
891
892   return continueTimer;
893 }
894
895 TextureSet AnimatedImageVisual::SetLoadingFailed()
896 {
897   DALI_LOG_INFO(gAnimImgLogFilter, Debug::Concise, "ResourceReady(ResourceStatus::FAILED)\n");
898   ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
899
900   Actor   actor     = mPlacementActor.GetHandle();
901   Vector2 imageSize = Vector2::ZERO;
902   if(actor)
903   {
904     imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
905   }
906   mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
907   TextureSet textureSet = mImpl->mRenderer.GetTextures();
908
909   if(mFrameDelayTimer)
910   {
911     mFrameDelayTimer.Stop();
912     mFrameDelayTimer.Reset();
913   }
914
915   SetImageSize(textureSet);
916
917   return textureSet;
918 }
919
920 void AnimatedImageVisual::AllocateMaskData()
921 {
922   if(!mMaskingData)
923   {
924     mMaskingData.reset(new TextureManager::MaskingData());
925   }
926 }
927
928 } // namespace Internal
929
930 } // namespace Toolkit
931
932 } // namespace Dali