Merge "Add Delete Key event in TextController" into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / texture-manager-impl.h
1 #ifndef DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
2 #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
3
4 /*
5  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19
20 // EXTERNAL INCLUDES
21 #include <deque>
22 #include <functional>
23 #include <string>
24 #include <memory>
25 #include <dali/public-api/common/dali-vector.h>
26 #include <dali/public-api/object/ref-object.h>
27 #include <dali/public-api/rendering/texture-set.h>
28 #include <dali/devel-api/common/owner-container.h>
29 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
30
31 // INTERNAL INCLUDES
32 #include <dali-toolkit/devel-api/image-loader/async-image-loader-devel.h>
33 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
34 #include <dali-toolkit/public-api/image-loader/async-image-loader.h>
35 #include <dali-toolkit/internal/visuals/texture-upload-observer.h>
36 #include <dali-toolkit/internal/visuals/visual-url.h>
37 #include <dali-toolkit/internal/helpers/round-robin-container-view.h>
38 #include <dali-toolkit/internal/image-loader/async-image-loader-impl.h>
39
40
41 namespace Dali
42 {
43
44 namespace Toolkit
45 {
46
47 namespace Internal
48 {
49 class ImageAtlasManager;
50 typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
51
52 /**
53  * The TextureManager provides a common Image loading API for Visuals.
54  *
55  * The TextureManager is responsible for providing sync, async, atlased and non-atlased loads.
56  * Texture caching is provided and performed when possible.
57  * Broken Images are automatically provided on load failure.
58  */
59 class TextureManager : public ConnectionTracker
60 {
61 public:
62
63   typedef int32_t TextureId;       ///< The TextureId type. This is used as a handle to refer to a particular Texture.
64   static const int INVALID_TEXTURE_ID = -1; ///< Used to represent a null TextureId or error
65
66   /**
67    * Whether the texture should be atlased or uploaded into it's own GPU texture
68    */
69   enum UseAtlas
70   {
71     NO_ATLAS,
72     USE_ATLAS
73   };
74
75   /**
76    * Whether the pixel data should be kept in TextureManager, or uploaded for rendering
77    */
78   enum StorageType
79   {
80     KEEP_PIXEL_BUFFER,
81     UPLOAD_TO_TEXTURE
82   };
83
84   /**
85    * Whether the texture should be loaded synchronously or asynchronously.
86    */
87   enum LoadType
88   {
89     LOAD_ASYNCHRONOUSLY,
90     LOAD_SYNCHRONOUSLY
91   };
92
93   /**
94    * @brief The LoadState Enumeration represents the current state of a particular Texture's life-cycle.
95    */
96   enum LoadState
97   {
98     NOT_STARTED,     ///< Default
99     LOADING,         ///< Loading has been started, but not finished.
100     LOAD_FINISHED,   ///< Loading has finished. (for CPU storage only)
101     WAITING_FOR_MASK,///< Loading has finished, but waiting for mask image
102     UPLOADED,        ///< Uploaded and ready. (For GPU upload only)
103     CANCELLED,       ///< Removed before loading completed
104     LOAD_FAILED      ///< Async loading failed, e.g. connection problem
105   };
106
107 public:
108
109   struct MaskingData
110   {
111     MaskingData();
112     ~MaskingData() = default;
113
114     VisualUrl mAlphaMaskUrl;
115     TextureManager::TextureId mAlphaMaskId;
116     float mContentScaleFactor;
117     bool mCropToMask;
118   };
119   using MaskingDataPointer = std::unique_ptr<MaskingData>;
120
121   /**
122    * Constructor.
123    */
124   TextureManager();
125
126   /**
127    * Destructor.
128    */
129   ~TextureManager() = default;
130
131
132   // TextureManager Main API:
133
134   TextureSet LoadTexture(VisualUrl& url, Dali::ImageDimensions desiredSize,
135                          Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode,
136                          const MaskingDataPointer& maskInfo, bool synchronousLoading,
137                          TextureManager::TextureId& textureId, Vector4& textureRect,
138                          bool& atlasingStatus, bool& loadingStatus, Dali::WrapMode::Type wrapModeU,
139                          Dali::WrapMode::Type wrapModeV, TextureUploadObserver* textureObserver,
140                          AtlasUploadObserver* atlasObserver,
141                          ImageAtlasManagerPtr imageAtlasManager,
142                          bool orientationCorrection );
143
144   /**
145    * @brief Requests an image load of the given URL.
146    *
147    * The parameters are used to specify how the image is loaded.
148    * The observer has the UploadComplete method called when the load is ready.
149    *
150    * When the client has finished with the Texture, Remove() should be called.
151    *
152    * @param[in] url                   The URL of the image to load
153    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
154    * @param[in] fittingMode           The FittingMode to use
155    * @param[in] samplingMode          The SamplingMode to use
156    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
157    *                                  but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver.
158    * @param[in] observer              The client object should inherit from this and provide the "UploadCompleted" virtual.
159    *                                  This is called when an image load completes (or fails).
160    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
161    * @return                          A TextureId to use as a handle to reference this Texture
162    */
163   TextureId RequestLoad( const VisualUrl&         url,
164                          const ImageDimensions    desiredSize,
165                          FittingMode::Type        fittingMode,
166                          Dali::SamplingMode::Type samplingMode,
167                          const UseAtlas           useAtlasing,
168                          TextureUploadObserver*   observer,
169                          bool                     orientationCorrection );
170
171   /**
172    * @brief Requests an image load of the given URL, when the texture has
173    * have loaded, it will perform a blend with the image mask, and upload
174    * the blended texture.
175    *
176    * The parameters are used to specify how the image is loaded.
177    * The observer has the UploadComplete method called when the load is ready.
178    *
179    * When the client has finished with the Texture, Remove() should be called.
180    *
181    * @param[in] url                   The URL of the image to load
182    * @param[in] maskTextureId         The texture id of an image to mask this with (can be INVALID if no masking required)
183    * @param[in] contentScale          The scale factor to apply to the image before masking
184    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
185    * @param[in] fittingMode           The FittingMode to use
186    * @param[in] samplingMode          The SamplingMode to use
187    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
188    *                                  but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver.
189    * @param[in] cropToMask            Only used with masking, this will crop the scaled image to the mask size. If false, then the mask will be scaled to fit the image before being applied.
190    * @param[in] observer              The client object should inherit from this and provide the "UploadCompleted" virtual.
191    *                                  This is called when an image load completes (or fails).
192    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
193    * @return                          A TextureId to use as a handle to reference this Texture
194    */
195   TextureId RequestLoad( const VisualUrl&         url,
196                          TextureId                maskTextureId,
197                          float                    contentScale,
198                          const ImageDimensions    desiredSize,
199                          FittingMode::Type        fittingMode,
200                          Dali::SamplingMode::Type samplingMode,
201                          const UseAtlas           useAtlasing,
202                          bool                     cropToMask,
203                          TextureUploadObserver*   observer,
204                          bool                     orientationCorrection );
205
206   /**
207    * Requests a masking image to be loaded. This mask is not uploaded to GL,
208    * instead, it is stored in CPU memory, and can be used for CPU blending.
209    */
210   TextureId RequestMaskLoad( const VisualUrl& maskUrl );
211
212   /**
213    * @brief Remove a Texture from the TextureManager.
214    *
215    * Textures are cached and therefore only the removal of the last
216    * occurrence of a Texture will cause its removal internally.
217    *
218    * @param[in] textureId The ID of the Texture to remove.
219    */
220   void Remove( const TextureManager::TextureId textureId );
221
222   /**
223    * Get the visualUrl associated with the texture id
224    */
225   const VisualUrl& GetVisualUrl( TextureId textureId );
226
227   /**
228    * @brief Get the current state of a texture
229    * @param[in] textureId The texture id to query
230    * @return The loading state if the texture is valid, or NOT_STARTED if the textureId
231    * is not valid.
232    */
233   LoadState GetTextureState( TextureId textureId );
234
235   /**
236    * @brief Get the associated texture set if the texture id is valid
237    * @param[in] textureId The texture Id to look up
238    * @return the associated texture set, or an empty handle if textureId is not valid
239    */
240   TextureSet GetTextureSet( TextureId textureId );
241
242   /**
243    * Adds an external texture to the texture manager
244    * @param[in] texture The texture to add
245    * @return string containing the URL for the texture
246    */
247   std::string AddExternalTexture( TextureSet& texture );
248
249   /**
250    * Removes an external texture from texture manager
251    * @param[in] url The string containing the texture to remove
252    * @return handle to the texture
253    */
254   TextureSet RemoveExternalTexture( const std::string& url );
255
256 private:
257
258   /**
259    * @brief Requests an image load of the given URL, when the texture has
260    * have loaded, if there is a valid maskTextureId, it will perform a
261    * CPU blend with the mask, and upload the blend texture.
262    *
263    * The parameters are used to specify how the image is loaded.
264    * The observer has the UploadComplete method called when the load is ready.
265    *
266    * When the client has finished with the Texture, Remove() should be called.
267    *
268    * @param[in] url                   The URL of the image to load
269    * @param[in] maskTextureId         The texture id of an image to use as a mask. If no mask is required, then set to INVALID_TEXTURE_ID
270    * @param[in] contentScale          The scaling factor to apply to the content when masking
271    * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
272    * @param[in] fittingMode           The FittingMode to use
273    * @param[in] samplingMode          The SamplingMode to use
274    * @param[in] useAtlasing           Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
275    *                                  but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver.
276    * @param[in] cropToMask            Whether to crop the target after masking, or scale the mask to the image before masking.
277    * @param[in] storageType,          Whether the pixel data is stored in the cache or uploaded to the GPU
278    * @param[in] observer              The client object should inherit from this and provide the "UploadCompleted" virtual.
279    *                                  This is called when an image load completes (or fails).
280    * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
281    * @return                          A TextureId to use as a handle to reference this Texture
282    */
283   TextureId RequestLoadInternal(
284     const VisualUrl&         url,
285     TextureId                maskTextureId,
286     float                    contentScale,
287     const ImageDimensions    desiredSize,
288     FittingMode::Type        fittingMode,
289     Dali::SamplingMode::Type samplingMode,
290     UseAtlas                 useAtlas,
291     bool                     cropToMask,
292     StorageType              storageType,
293     TextureUploadObserver*   observer,
294     bool                     orientationCorrection );
295
296
297   typedef size_t TextureHash; ///< The type used to store the hash used for Texture caching.
298
299   /**
300    * @brief This struct is used to manage the life-cycle of Texture loading and caching.
301    */
302   struct TextureInfo
303   {
304     TextureInfo( TextureId textureId,
305                  TextureId maskTextureId,
306                  const VisualUrl& url,
307                  ImageDimensions desiredSize,
308                  float scaleFactor,
309                  FittingMode::Type fittingMode,
310                  Dali::SamplingMode::Type samplingMode,
311                  bool loadSynchronously,
312                  bool cropToMask,
313                  UseAtlas useAtlas,
314                  TextureManager::TextureHash hash,
315                  bool orientationCorrection )
316     : url( url ),
317       desiredSize( desiredSize ),
318       useSize( desiredSize ),
319       atlasRect( 0.0f, 0.0f, 1.0f, 1.0f ), // Full atlas rectangle
320       textureId( textureId ),
321       maskTextureId( maskTextureId ),
322       hash( hash ),
323       scaleFactor( scaleFactor ),
324       referenceCount( 1u ),
325       loadState( NOT_STARTED ),
326       fittingMode( fittingMode ),
327       samplingMode( samplingMode ),
328       storageType( UPLOAD_TO_TEXTURE ),
329       loadSynchronously( loadSynchronously ),
330       useAtlas( useAtlas ),
331       cropToMask( cropToMask ),
332       orientationCorrection( true )
333     {
334     }
335
336     /**
337      * Container type used to store all observer clients of this Texture
338      */
339     typedef Dali::Vector< TextureUploadObserver* > ObserverListType;
340
341     ObserverListType observerList; ///< Container used to store all observer clients of this Texture
342     Toolkit::ImageAtlas atlas;     ///< The atlas this Texture lays within (if any)
343     Devel::PixelBuffer pixelBuffer;///< The PixelBuffer holding the image data (May be empty after upload)
344     TextureSet textureSet;         ///< The TextureSet holding the Texture
345     VisualUrl url;                 ///< The URL of the image
346     ImageDimensions desiredSize;   ///< The size requested
347     ImageDimensions useSize;       ///< The size used
348     Vector4 atlasRect;             ///< The atlas rect used if atlased
349     TextureId textureId;           ///< The TextureId associated with this Texture
350     TextureId maskTextureId;       ///< The mask TextureId to be applied on load
351     TextureManager::TextureHash hash; ///< The hash used to cache this Texture
352     float scaleFactor;             ///< The scale factor to apply to the Texture when masking
353     int16_t referenceCount;        ///< The reference count of clients using this Texture
354     LoadState loadState:3;         ///< The load state showing the load progress of the Texture
355     FittingMode::Type fittingMode:2; ///< The requested FittingMode
356     Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode
357     StorageType storageType:1;     ///< CPU storage / GPU upload;
358     bool loadSynchronously:1;      ///< True if synchronous loading was requested
359     UseAtlas useAtlas:1;           ///< USE_ATLAS if an atlas was requested. This is updated to false if atlas is not used
360     bool cropToMask:1;             ///< true if the image should be cropped to the mask size.
361     bool orientationCorrection:1;  ///< true if the image should be rotated to match exif orientation data
362   };
363
364   // Structs:
365
366   /**
367    * Struct to hold information about a requested Async load.
368    * This is used to look up a TextureManager::TextureId from the returned AsyncLoad Id.
369    */
370   struct AsyncLoadingInfo
371   {
372     AsyncLoadingInfo( TextureId textureId )
373     : textureId( textureId ),
374       loadId( 0 )
375     {
376     }
377
378     TextureId           textureId;   ///< The external Texture Id assigned to this load
379     unsigned short      loadId;      ///< The load Id used by the async loader to reference this load
380   };
381
382   // Private typedefs:
383
384   typedef std::deque<AsyncLoadingInfo>  AsyncLoadingInfoContainerType;  ///< The container type used to manage Asynchronous loads in progress
385   typedef std::vector<TextureInfo>      TextureInfoContainerType;       ///< The container type used to manage the life-cycle and caching of Textures
386
387   /**
388    * @brief Used internally to initiate a load.
389    * @param[in] textureInfo The TextureInfo struct associated with the Texture
390    * @return                True if the load was initiated
391    */
392   bool LoadTexture( TextureInfo& textureInfo );
393
394   /**
395    * Add the observer to the observer list
396    * @param[in] textureInfo The TextureInfo struct associated with the texture
397    * observer The observer wishing to observe the texture upload
398    */
399   void ObserveTexture( TextureInfo & textureInfo, TextureUploadObserver* observer );
400
401   /**
402    * @brief This signal handler is called when the async local loader finishes loading.
403    * @param[in] id        This is the async image loaders Id
404    * @param[in] pixelBuffer The loaded image data
405    */
406   void AsyncLocalLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer );
407
408   /**
409    * @brief This signal handler is called when the async local loader finishes loading.
410    * @param[in] id        This is the async image loaders Id
411    * @param[in] pixelBuffer The loaded image data
412    */
413   void AsyncRemoteLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer );
414
415   /**
416    * Common method to handle loading completion
417    * @param[in] container The Async loading container
418    * @param[in] id        This is the async image loaders Id
419    * @param[in] pixelBuffer The loaded image data
420    */
421   void AsyncLoadComplete( AsyncLoadingInfoContainerType& container, uint32_t id, Devel::PixelBuffer pixelBuffer );
422
423   /**
424    * @brief Performs Post-Load steps including atlasing.
425    * @param[in] textureInfo The struct associated with this Texture
426    * @param[in] pixelBuffer The image pixelBuffer
427    * @return    True if successful
428    */
429   void PostLoad( TextureManager::TextureInfo& textureInfo, Devel::PixelBuffer& pixelBuffer );
430
431   /**
432    * Check if there is a texture waiting to be masked. If there
433    * is then apply this mask and upload it.
434    * @param[in] maskTextureInfo The texture info of the mask that has just loaded.
435    */
436   void CheckForWaitingTexture( TextureInfo& maskTextureInfo );
437
438   /**
439    * Apply the mask to the pixelBuffer.
440    * @param[in] pixelBuffer The pixelBuffer to apply the mask to
441    * @param[in] maskTextureId The texture id of the mask.
442    * @param[in] contentScale The factor to scale the content
443    * @param[in] cropToMask Whether to crop the content to the mask size
444    */
445   void ApplyMask( Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId,
446                   float contentScale, bool cropToMask );
447
448   /**
449    * Upload the texture specified in pixelBuffer to the appropriate location
450    * @param[in] pixelBuffer The image data to upload
451    * @param[in] textureInfo The texture info containing the location to
452    * store the data to.
453    */
454   void UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo );
455
456   /**
457    * Mark the texture as complete, and inform observers
458    * @param[in] textureInfo The struct associated with this Texture
459    */
460   void UploadComplete( TextureInfo& textureInfo );
461
462   /**
463    * Notify the current observers that the texture upload is complete,
464    * then remove the observers from the list.
465    * @param[in] textureInfo The struct associated with this Texture
466    * @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
467    */
468   void NotifyObservers( TextureInfo& textureInfo, bool success );
469
470   /**
471    * @brief Generates a new, unique TextureId
472    * @return A unique TextureId
473    */
474   TextureManager::TextureId GenerateUniqueTextureId();
475
476   /**
477    * @brief Used to lookup an index into the TextureInfoContainer from a TextureId
478    * @param[in] textureId The TextureId to look up
479    * @return              The cache index
480    */
481   int GetCacheIndexFromId( TextureId textureId );
482
483
484   /**
485    * @brief Generates a hash for caching based on the input parameters.
486    * Only applies size, fitting mode andsampling mode if the size is specified.
487    * Only applies maskTextureId if it isn't INVALID_TEXTURE_ID
488    * Always applies useAtlas.
489    * @param[in] url          The URL of the image to load
490    * @param[in] size         The image size
491    * @param[in] fittingMode  The FittingMode to use
492    * @param[in] samplingMode The SamplingMode to use
493    * @param[in] useAtlas     True if atlased
494    * @param[in] maskTextureId The masking texture id (or INVALID_TEXTURE_ID)
495    * @return                 A hash of the provided data for caching.
496    */
497   TextureHash GenerateHash( const std::string& url, const ImageDimensions size,
498                             const FittingMode::Type fittingMode,
499                             const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas,
500                             TextureId maskTextureId );
501   /**
502    * @brief Looks up a cached texture by its hash.
503    * If found, the given parameters are used to check there is no hash-collision.
504    * @param[in] hash          The hash to look up
505    * @param[in] url           The URL of the image to load
506    * @param[in] size          The image size
507    * @param[in] fittingMode   The FittingMode to use
508    * @param[in] samplingMode  The SamplingMode to use
509    * @param[in] useAtlas      True if atlased
510    * @param[in] maskTextureId Optional texture ID to use to mask this image
511    * @return A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found.
512    */
513   TextureManager::TextureId FindCachedTexture(
514     const TextureManager::TextureHash hash,
515     const std::string& url,
516     const ImageDimensions size,
517     const FittingMode::Type fittingMode,
518     const Dali::SamplingMode::Type samplingMode,
519     const bool useAtlas,
520     TextureId maskTextureId );
521
522 private:
523
524   /**
525    * @brief Helper class to keep the relation between AsyncImageLoader and corresponding LoadingInfo container
526    */
527   class AsyncLoadingHelper : public ConnectionTracker
528   {
529   public:
530     /**
531      * @brief Create an AsyncLoadingHelper.
532      * @param[in] textureManager Reference to the texture manager
533      */
534     AsyncLoadingHelper(TextureManager& textureManager);
535
536     /**
537      * @brief Load a new texture.
538      * @param[in] textureId             TextureId to reference the texture that will be loaded
539      * @param[in] url                   The URL of the image to load
540      * @param[in] desiredSize           The size the image is likely to appear at. This can be set to 0,0 for automatic
541      * @param[in] fittingMode           The FittingMode to use
542      * @param[in] samplingMode          The SamplingMode to use
543      * @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image, e.g., from portrait to landscape
544      */
545     void Load(TextureId textureId,
546               const VisualUrl& url,
547               ImageDimensions desiredSize,
548               FittingMode::Type fittingMode,
549               SamplingMode::Type samplingMode,
550               bool orientationCorrection);
551
552   public:
553     AsyncLoadingHelper(const AsyncLoadingHelper&) = delete;
554     AsyncLoadingHelper& operator=(const AsyncLoadingHelper&) = delete;
555
556     AsyncLoadingHelper(AsyncLoadingHelper&& rhs);
557     AsyncLoadingHelper& operator=(AsyncLoadingHelper&&rhs) = delete;
558
559   private:
560     /**
561      * @brief Main constructor that used by all other constructors
562      */
563     AsyncLoadingHelper(Toolkit::AsyncImageLoader loader,
564                        TextureManager& textureManager,
565                        AsyncLoadingInfoContainerType&& loadingInfoContainer);
566
567     /**
568      * @brief Callback to be called when texture loading is complete, it passes the pixel buffer on to texture manager.
569      * @param[in] id          Loader id
570      * @param[in] pixelBuffer Image data
571      */
572     void AsyncLoadComplete(uint32_t id, Devel::PixelBuffer pixelBuffer);
573
574   private:
575     Toolkit::AsyncImageLoader     mLoader;
576     TextureManager&               mTextureManager;
577     AsyncLoadingInfoContainerType mLoadingInfoContainer;
578   };
579
580   struct ExternalTextureInfo
581   {
582     TextureId textureId;
583     TextureSet textureSet;
584   };
585
586 private:
587
588   /**
589    * Deleted copy constructor.
590    */
591   TextureManager( const TextureManager& ) = delete;
592
593   /**
594    * Deleted assignment operator.
595    */
596   TextureManager& operator=( const TextureManager& rhs ) = delete;
597
598   /**
599    * This is called by the TextureManagerUploadObserver when an observer is destroyed.
600    * We use the callback to know when to remove an observer from our notify list.
601    * @param[in] observer The observer that generated the callback
602    */
603   void ObserverDestroyed( TextureUploadObserver* observer );
604
605 private:  // Member Variables:
606
607   TextureInfoContainerType                      mTextureInfoContainer; ///< Used to manage the life-cycle and caching of Textures
608   RoundRobinContainerView< AsyncLoadingHelper > mAsyncLocalLoaders;    ///< The Asynchronous image loaders used to provide all local async loads
609   RoundRobinContainerView< AsyncLoadingHelper > mAsyncRemoteLoaders;   ///< The Asynchronous image loaders used to provide all remote async loads
610   std::vector< ExternalTextureInfo >            mExternalTextures;     ///< Externally provided textures
611   TextureId                                     mCurrentTextureId;     ///< The current value used for the unique Texture Id generation
612
613 };
614
615
616 } // name Internal
617
618 } // namespace Toolkit
619
620 } // namespace Dali
621
622 #endif // DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H