/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    Texture Manager component

*

*/

#ifndef C_GLXTEXTUREMANAGERIMPL_H

#define C_GLXTEXTUREMANAGERIMPL_H

#include <e32base.h>

#include <badesca.h>    // For CDesCArrayFlat

#include <e32cmn.h>

#include <AknsItemID.h>

#include <alf/alftexture.h>

#include <alf/alfbitmapprovider.h>

#include <alf/alftimedvalue.h>

#include <mpxattribute.h>

#include <mglxresolutionchangeobserver.h>

#include "glxbitmapdecoderwrapper.h"

#include <glxmediaid.h>

#include <glximageviewermanager.h>

#include <imageconversion.h>

#include <bitmaptransforms.h>

#include <mglxcacheobserver.h>

class CAlfTexture;

class CGlxDRMUtility;

class CGlxMedia;

//class CAlfGifAnimationTexture;

class CAlfImageLoaderUtil;

class CAlfTextureManager;

class MGlxCache;

class TGlxMedia;

class CGlxResolutionUtility;

class MGlxTextureObserver;

class CGlxBitmapDecoderWrapper;

class MGlxBitmapDecoderObserver;

class CGlxThumbnailAttribute;

/**

 *  CGlxTextureManagerImpl

 *

 *  Implementation of Texture Manager component. 

 *

 * @author David Holland

 * @internal reviewed 03/07/2007 by Dan Rhodes

 *

 */

class CGlxTextureManagerImpl : public CBase, public MAlfBitmapProvider,

                                         public MGlxResolutionChangeObserver,

										 public MGlxBitmapDecoderObserver,

										 public MGlxCacheObserver

    {

public:

    /**

    * Two-phased constructor

    * @param aAlfTextureManager The Alf Texture Manager

    * @return Constructed object

    */

    static CGlxTextureManagerImpl* NewL(

                                CAlfTextureManager& aAlfTextureManager);

    /**

    * Two-phased constructor

    * @param aAlfTextureManager The Alf Texture Manager

    * @return Constructed object

    */

    static CGlxTextureManagerImpl* NewLC(

                                CAlfTextureManager& aAlfTextureManager);

    /**

    * Destructor

    */      

    ~CGlxTextureManagerImpl();

    /**

     * Determins if the texture need updating

     * @param aMediaId The Id of the media item

     * @param aIdSpaceId The Id of the Id space in which the media Id is defined

     * @param aRequiredSize The preferred size of the texture

     * @return ETrue if the texture needs updating. EFalse if not.

     */

    TBool TextureNeedsUpdating(TGlxMedia aMedia, TGlxIdSpaceId aIdSpaceId,

                                                const TSize& aRequiredSize);

    /**

    * Create a texture from an icon within the application

    * @param aSkinID The skin Id associated with the icon 

    * @param aIconResourceId The Id associated with the icon .mif file

    * @param aFilename The full path name of the .mif file

    * @param aSetColor ETrue if colour of icon is to be modified

    * @param aDefaultColor colour use if skin clour not specified or not found

    * @param aSkinColorId Id of the skin colour table

    * @param aSkinColorIndex Index of the colour in the table

    * @param aRequestedSize requested size. If default used size is based on size of original graphic

    * @return Created texture

    */

    CAlfTexture& CreateIconTextureL(const TAknsItemID& aSkinID,

                                    TInt aIconResourceId, 

                                    const TDesC& aFilename,

                                    TBool aSetColor,

                                    TRgb aDefaultColor,

                                    const TAknsItemID& aSkinColorId,

                                    TInt aSkinColorIndex,

                                    TSize aRequestedSize);

    /**

     * Requests the best match texture. If it already exists this method does nothing.

     * However if it doed not exist it will create it and replace the old texture

     * if necessary.

     * @param aSize The size of the requested texture

     * @param aMedia The TGlxMedia item

     * @param aIdSpaceId The Id of the Id space in which the media Id is defined

     * @param aObserver Observer for the texture.

	 * @param aScaleGridTnm ETrue if the grid tnm to be scaled else EFalse.

     * @return Created texture, or NULL if the texture alreay exists

     */

    CAlfTexture& CreateNewTextureForMediaL(TSize aSize, const TGlxMedia& aMedia,

        const TGlxIdSpaceId& aIdSpaceId, MGlxTextureObserver* aObserver, TBool aScaleGridTnm );

    /**

    * Create a texture from a zoomed thumbnail attribute of a media item

    * @param aMedia The media item

    * @param aAttribute Which attribute

    * @param aIdSpaceId The Id of the Id space in which the media Id is defined

    * @param aObserver Observer for the texture.

    * @return Created texture

    */

    CAlfTexture& CreateZoomedTextureL(const TGlxMedia& aMedia,

                                            const TMPXAttribute& aAttribute,

                                            TGlxIdSpaceId aIdSpaceId, MGlxTextureObserver* aObserver);

    /**

    * If we have a texture ID, we recreate the Zoomed texture based on that

    * 

    * @param aTextureID the texture ID to create the texture on. 

    */

    CAlfTexture* CreateZoomedTextureL( );

    /**

    * Create an animated texture from a GIF file

    * @param aFilename The filename of the GIF file

    * @param aSize The size of the GIF file

	* @param aMedia The media item

	* @param aIdSpaceId The Id of the Id space in which the media Id is defined	

    * @return Created texture: ownership transfered

    */

    CAlfTexture& CreateAnimatedGifTextureL(const TDesC& aFilename, const TSize& aSize,

                                           const TGlxMedia& aMedia, TGlxIdSpaceId aIdSpaceId);

    /**

     * Removes the texture if it was created by CreateThumbnailTextureL or

     * CreateZoomedTextureL

     * @param aTexture The texture to be removed

     */

    void RemoveTexture( const CAlfTexture& aTexture );

    /**

     * Removes all Texteures 

     * 

     */

    void FlushTextures() ;

    /**

     * Removes the texture if it was created by CreateThumbnailTextureL or

     * CreateZoomedTextureL

     * @param aTexture The texture to be removed

     */

    void RemoveZoomList();

    /**

     * Removes the texture if it was created by CreateThumbnailTextureL or

     * CreateZoomedTextureL

     * @param TGlxMediaId The iMediaId to be removed

     * @param aAllTexture Flag to remove all textures

	 * Bug fix for PKAA-7NRBYZ - added bAllTexture param.

     */

    void RemoveTexture( const TGlxMediaId& aMediaId, TBool aAllTexture);

    /**

     * Creates a flat color texture and returns the reference to it

     */

    CAlfTexture& CreateFlatColourTextureL( TRgb aColour );   

   /**

    * Animate the given media.

    * @param aMediaId The Id of the media to be animated

    * @param aState Animation state [ETrue to Start, EFalse to Stop]

    */

    void AnimateMediaItem(const TGlxMediaId& aMediaId, TBool aState);

public:  // From MGlxCacheObserver

    void HandleAttributesAvailableL(const TGlxIdSpaceId& aIdSpaceId, 

                                    const TGlxMediaId& aMediaId, 

                                    const RArray<TMPXAttribute>& aAttributes, 

                                    const CGlxMedia* aMedia);

    void CleanupMedia(const TGlxMediaId& aMediaId);

public: // from MAlfBitmapProvider

    void ProvideBitmapL(TInt aId, 

                        CFbsBitmap*& aBitmap, 

                        CFbsBitmap*& aMaskBitmap);

public: // From MGlxResolutionChangeObserver    

    void HandleResolutionChangedL();

    /**

    * Updates the texture for every Icon in the IconList.

    */

    void UpdateTexture();

public: // From MGlxTextureRotatorObserver    

    void HandleBitmapDecodedL(TInt aThumbnailIndex,CFbsBitmap* aBitmap);

private:

    /**

    * Constructor

    * @param aAlfTextureManager The Alf Texture Manager

    */

    CGlxTextureManagerImpl(CAlfTextureManager& aAlfTextureManager);

    /**

    * Second-phase constuction

    */

    void ConstructL();

    /**

    * GetThumbnailAttributeAndIndexL

    * @param aSize The size of the requested texture

    * @param aMedia The TGlxMedia item.

    * @param aThumbnailIndex on return will contain the Index of the thumbnail in the iThumbnailList

    *        or KErrNotFound

    * @param aThumbnailAttribute on return will contain the Thumbnail attribute (if found)

    * @return ETrue if Thumbnail is available, EFalse if it needs to be created

    */

    TBool GetThumbnailAttributeAndIndexL( TSize aSize, const TGlxMedia& aMedia,

        const TGlxIdSpaceId& aIdSpaceId, TInt& aThumbnailIndex,

        TMPXAttribute& aThumbnailAttribute );

    /**

     * Create Image Viewer manager Instance

     */

    void CreateImageViewerInstanceL();

    /**

     * Delete Image Viewer manager Instance

     */

    void DeleteImageViewerInstance();

    /**

     * TGlxIcon

     * Values associated with a bitmap/svg icon

     */

    class TGlxIcon 

    {

    public:

        TInt           iTextureId;

        CAlfTexture*   iTexture;

        TAknsItemID    iAvkonSkinId;

        TInt           iBitmapId;

        TInt           iFilenameIndex;

        TBool          iSetColor;    // indicates if color to be modified

        TRgb           iDefaultColor;

        TAknsItemID    iSkinColorId;

        TInt           iSkinColorIndex;

        TReal32        iHeightInPoss;

        TReal32        iWidthInPoss;

        /**

         * Helper functor to be able to find texture from array

         */

        static TBool MatchTexture( 

                const CAlfTexture* aTexture, 

                const TGlxIcon& aRhs )

        	{

        	// return true if the address of the texture match

        	return aTexture == aRhs.iTexture;

        	}

        };

    /**

     * TGlxThumbIcon

     * Values associated with a thumbnail.

     */

    class TGlxThumbnailIcon 

        {

    public:

        TInt              iTextureId;

        CAlfTexture*      iTexture;

        TMPXAttribute     iAttribId;

        TSize             iRequiredSize;

        TGlxMediaId       iMediaId;

        TGlxIdSpaceId     iIdSpaceId;

        MGlxTextureObserver* iObserver;

        CFbsBitmap*         iBitmap;

		TTime				iImageDate; 

        /**

         * Helper function to be able to find texture from array

         */

        static TBool MatchTexture( 

            const CAlfTexture* aTexture, 

            const TGlxThumbnailIcon& aThumbData )

        	{

        	// return true if the address of the texture match

        	return aTexture == aThumbData.iTexture;

        	}

        /**

         * Helper function to be able to find mediaid from array

         */

        static TBool MatchMediaId(const TGlxMediaId* aMediaId,

                const TGlxThumbnailIcon& aThumbData)

            {

        	// return true if the Media Id match

            return *aMediaId == aThumbData.iMediaId;

            }

         };

    /**

    * Requests the best match texture. If it already exists this method does nothing.

    * However if it doed not exist it will create it and replace the old texture

    * if necessary.

    * @param aSize The size of the requested texture

    * @param aMedia The TGlxMedia item

    * @param aIdSpaceId The Id of the Id space in which the media Id is defined

    * @param aObserver Observer for the texture.

    * @param aAttribute specifies the type of texture to create

    * @param aThumbData the tumbnail data

    * @param aScaleGridTnm ETrue if the grid tnm to be scaled else EFalse.	

    * @return Created texture, or NULL if the texture alreay exists

    */

    CAlfTexture& CreateNewTextureL( TSize aSize, const TGlxMedia& aMedia,

        const TGlxIdSpaceId& aIdSpaceId, MGlxTextureObserver* aObserver,

        TMPXAttribute& aAttribute, TGlxThumbnailIcon& aThumbData,TBool aIsThumbnailTexture, TBool aScaleGridTnm);

    /**

     * TGlxProvideBitmapHolder

     * Used to hold the bitmaps and their associated texture id between

     * the call to create the alf texture and the callback to ProvideBitmap.

     */

    class TGlxProvideBitmapHolder

        {

    public:

        TInt iTextureId;

        CFbsBitmap* iBitmap;        // not owned

        CFbsBitmap* iMaskBitmap;    // not owned

        };

    /**

    * Select the most appropriate attribute to use to load bitmap

    * @param aThumbnail contains the data concerning the texture

    * @param aMedia the media 

    * @return Index of selected attribute in list or KErrNotFound

    */

    TMPXAttribute SelectAttributeL(TSize& aThumbnail,

                          const TGlxMedia& aMedia);

    /**

    * Duplicates a bitmap

    * @param aOriginalBitmap original bitmap

    * @return duplicate bitmap

    */

    CFbsBitmap* CreateDuplicateBitmapL( CFbsBitmap& aOriginalBitmap );

    /**

    * Increments the texture id and returns it

    * @return next texture id

    */

    TInt NextTextureId();

    /**

    * Scales the grid Thumbnail bitmap to the fullscreen keeping the aspect 

    * ratio.

    * @param aSrcSize The size of the original image

    * @param aDestSize The Fullscreen size

    * @param aScaledBitmap Pointer to the scaled bitmap

    * @param thumb thumbnail attributes.

    */    

    void ScaleGridTnmToFsL(TSize aSrcSize, TSize aDestSize, 

            CFbsBitmap *aScaledBitmap, const CGlxThumbnailAttribute* thumb);

    /**

    * GetAnimatedGifThumbnailIndex

    * @param aSize The size of the requested texture

    * @param aMedia The TGlxMedia item.

    * @param aIdSpaceId The Id of the Id space in which the media Id is defined	

    * @param aThumbnailIndex on return will contain the Index of the thumbnail in the iAnimatedTnmList

    *        or KErrNotFound

    * @return ETrue if Thumbnail is available, EFalse if it needs to be created

    */

            const TGlxMedia& aMedia, const TGlxIdSpaceId& aIdSpaceId,

            TInt& aThumbnailIndex);

private:

    // Alf Texture manager (not owned) 

    CAlfTextureManager& iAlfTextureManager;

    // Next id to be allocated to icon textures provide within the application. 

    TInt iNextTextureId;

    // List containing data for icon textures provided within the application. 

    RArray<TGlxIcon> iIconList;

    // List containing data for textures generated from thumbnail bitmaps. 

    RArray<TGlxThumbnailIcon> iThumbnailList;

    // List containing data for textures generated from zoomed thumbnail. 

    RArray<TGlxThumbnailIcon> iZoomedList;

    // List containing data for textures generated from Animated thumbnail. 

    RArray<TGlxThumbnailIcon> iAnimatedTnmList;

    // List of .mif filenames of files containing icons. 

    CDesCArrayFlat* iMifFilenames;

    // DRM utility class 

    CGlxDRMUtility* iDrmUtility;

    // MGlxCache instance 

    MGlxCache* iCache;

    // CGlxResolutionUtility instance 

    CGlxResolutionUtility* iResUtil;

	//The Bitmap Decoder Engine

	CGlxBitmapDecoderWrapper* iZoomDecoder; 

    // Temporary storage class used between call to create a texture and the 

    //callback from alf to ProvideBitmap 

    TGlxProvideBitmapHolder iProvideBitmapHolder;

    // For image viewer, not own

    CGlxImageViewerManager* iImageViewerInstance;

    };

#endif // C_GLXTEXTUREMANAGERIMPL_H