/*

* Copyright (c) 2006-2007 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:   

*

*/

#ifndef __HUICANVASTEXTURECACHE_H__

#define __HUICANVASTEXTURECACHE_H__

#include <e32base.h>

#include <uiacceltk/HuiCanvasCmdBufferReader.h>

#include <uiacceltk/HuiImage.h>

#include <uiacceltk/HuiTexture.h>

#include <uiacceltk/HuiCanvasVisual.h>

#include <uiacceltk/huilowmemoryobserver.h>

class CHuiTexture;

class CHuiCanvasVisual;

class CHuiCanvasRenderBuffer;

class CHuiCanvasTextImage;

class CHuiCanvasGraphicImage;

class CHuiCanvasRenderBufferImage;

class CHuiCanvasTextImageRasterizer;

class CHuiCanvasGraphicImageRasterizer;

class CHuiCanvasCombinedGraphicImageRasterizer;

class CHuiCanvasTextureCache;

NONSHARABLE_CLASS( THuiCachedGcParams )  

    {

public:

    THuiCachedGcParams() :    

        iPenColor(KHuiWsDefaultPenColor),

        iPenStyle(KHuiWsDefaultPenStyle),

        iDrawMode(KHuiWsDefaultDrawMode),

        iBrushColor(KHuiWsDefaultBrushColor),

        iBrushStyle(KHuiWsDefaultBrushStyle),

        iShadowMode(KHuiWsDefaultShadowMode),

        iStrikethrough(KHuiWsDefaultStrikethrough),

        iUnderline(KHuiWsDefaultUnderline),

        iUserDisplayMode(KHuiWsDefaultUserDisplayMode),

        iShadowColor(KHuiWsDefaultShadowColor)

            {

            }

    TRgb  iPenColor;

    TInt  iPenStyle;

    TInt  iDrawMode;

    TRgb  iBrushColor;

    TInt  iBrushStyle;

    TInt  iShadowMode;

    TInt  iStrikethrough;

    TInt  iUnderline;

    TInt  iUserDisplayMode;

    TRgb  iShadowColor;        

    };

NONSHARABLE_CLASS( THuiCachedImageParams )  

    {

public:

    THuiCachedImageParams() :    

        iBitmapHandle(0),

        iMaskHandle(0),

        iInvertedMask(EFalse),

        iMaskOriginPoint(TPoint(0,0))

            {

            }

    TInt iBitmapHandle;

    TInt iMaskHandle;

    TBool iInvertedMask;

    TPoint iMaskOriginPoint;

    THuiCachedGcParams iGcParams;

    };

NONSHARABLE_CLASS( THuiCachedCombinedImageParams )  

    {

public:

    THuiCachedCombinedImageParams() :    

        iBitmapHandle(0),

        iMaskHandle(0),

        iCombinedBitmapPoint(TPoint(0,0))

            {

            }

    TInt iBitmapHandle;

    TInt iMaskHandle;

    TPoint iCombinedBitmapPoint;

    };

NONSHARABLE_CLASS( THuiCachedTextParams )

    {      

public:

    THuiCachedTextParams() :

        iText(NULL),

        iFontHandle(0),

        iRasterizationOffset(TPoint(0,0)),

        iTextParams(THuiCanvasTextParameters()),

        iTextBoxMaxSize(TSize(KMinTInt,KMinTInt)),

        iTextWidth(KMinTInt),

        iBaseLineOffset(KMinTInt),

        iTextAlign(CGraphicsContext::ELeft),

        iMargin(0),

        iAngle(0)

            {

            }

    HBufC* iText;

    TPtr* iFindTextPtr;

    TInt iFontHandle;

    TPoint iRasterizationOffset;

    THuiCanvasTextParameters iTextParams;

    TSize iTextBoxMaxSize;        

    TInt iTextWidth;

    TInt iBaseLineOffset;

    TInt iTextAlign;

    TInt iMargin;

    TInt iAngle;

    THuiCachedGcParams iGcParams;

    };

NONSHARABLE_CLASS( THuiCachedBitmap )  

    {

public:

    THuiCachedBitmap() :    

        iBitmapHandle(0),

        iMaskHandle(0),

        iBitmap(0),

        iMask(0),

        iBitmapTouchCount(-1),

        iMaskTouchCount(-1),

        iInvertedMask(EFalse),

        iMaskOriginPoint(TPoint(0,0)),

        iCombinedBitmapPoint(TPoint(0,0))       

            {

            }

    TInt iBitmapHandle;

    TInt iMaskHandle;

    CFbsBitmap* iBitmap;

    CFbsBitmap* iMask;    

    TInt iBitmapTouchCount;

    TInt iMaskTouchCount;

    TBool iInvertedMask;

    TPoint iMaskOriginPoint;

    TPoint iCombinedBitmapPoint;

    };

NONSHARABLE_CLASS( CHuiCanvasImage ) : public CBase

    {

public:

    CHuiCanvasImage();

    ~CHuiCanvasImage();

    void RefreshUser(const CHuiCanvasVisual& aUser);

    void RemoveUser(const CHuiCanvasVisual& aUser);

    TBool IsUser(const CHuiCanvasVisual& aUser) const;

    TBool IsAnyUser() const;

    CHuiTexture* Texture() const;

    virtual void CopyAttributes(CHuiCanvasImage& aSrc);

    virtual void Reset();

public:

    CHuiTexture* iTexture;

    THuiCachedGcParams iGcParams;

    RPointerArray<CHuiCanvasVisual> iActiveUsers;

    TTime iLastUsed;

    CHuiCanvasTextureCache* iCache;

    };

NONSHARABLE_CLASS( CHuiCanvasGraphicImage ) : public CHuiCanvasImage

    {

public:

    CHuiCanvasGraphicImage();

    ~CHuiCanvasGraphicImage();

    virtual void CopyAttributes(CHuiCanvasGraphicImage& aSrc);

    virtual void Reset();

public:

    TInt iBitmapHandle;

    TInt iMaskHandle;

    CFbsBitmap* iBitmap;

    CFbsBitmap* iMask;    

    TBool iInvertedMask;

    TPoint iMaskOriginPoint;

    TInt iBitmapTouchCount;        

    TInt iMaskTouchCount;

    // Combined image

    RArray<THuiCachedBitmap> iSubImages;

    TSize iImageSize; 

    };

NONSHARABLE_CLASS( CHuiCanvasTextImage ) : public CHuiCanvasImage

    {

public:

    CHuiCanvasTextImage();

    ~CHuiCanvasTextImage();

    TBool UseColorModulation() const;

    virtual void CopyAttributes(CHuiCanvasTextImage& aSrc);

    virtual void Reset();

public:

    HBufC* iText;

    TPtr* iFindTextPtr;

    TInt iFontHandle;

    TPoint iRasterizationOffset;

    THuiCanvasTextParameters iTextParams;

    TSize iTextBoxMaxSize;        

    TInt iTextWidth;

    TInt iBaseLineOffset;

    TInt iTextAlign;

    TInt iMargin;

    TInt iAngle;

    TBool iUseColorModulation;

    // not owned

    CFbsBitGcFont* iFont;

    };

class CHuiCanvasTextureCache : public CBase, public MHuiLowMemoryObserver, public MHuiMemoryLevelObserver

    {

public:

	/**

	 * Constructor.

	 */

	CHuiCanvasTextureCache();

	/**

	 * Destructor.

	 */ 

	~CHuiCanvasTextureCache();

	/**

	 * Constructor.

	 */

	static CHuiCanvasTextureCache* NewL();

	/**

	 * Constructor.

	 */

    static CHuiCanvasTextureCache* NewLC();

    /**

     * Second-phase constructor.

     */

    void ConstructL();

    /**

     * Enables (disables) low memory state.

     * Deprecated

     */

    void EnableLowMemoryState(TBool aEnable);

    /**

     * Sets memory level. Alternative for EnableLowMemoryState().

     */

    void SetMemoryLevel(THuiMemoryLevel aLevel);

    /**

     * Gets memory level.

     */

    THuiMemoryLevel MemoryLevel();

	/**

	 * Finds cached combined image and updates it if needed. If not found creates new one into cache.

	 */ 

    const CHuiCanvasGraphicImage* CreateCombinedCachedImageL(const RArray<THuiCachedCombinedImageParams>& aCachedImageParams, 

        const THuiCachedGcParams& aGcParams,

        const TSize& aImageSize, 

        const CHuiCanvasVisual& aUser);

	/**

	 * Finds cached image and updates it if needed. If not found creates new one into cache.

	 */ 

    const CHuiCanvasGraphicImage* CreateCachedImageL(const THuiCachedImageParams& aCachedImageParams, const CHuiCanvasVisual& aUser);

	/**

	 * Finds cached image, but does not update it. If not found, leave happens.

	 */ 

    const CHuiCanvasGraphicImage* FindCachedImageL(const THuiCachedImageParams& aCachedImageParams, const CHuiCanvasVisual& aUser);

	/**

	 * Finds cached text and updates it if needed. If not found creates new one into cache.

	 */ 

    const CHuiCanvasTextImage* CreateCachedTextL(const THuiCachedTextParams& aCachedTextParams, const CHuiCanvasVisual& aUser);

    /**

     * Finds cached render buffer, if not found it is created. Ownership is not transferred to the caller.  

     * 

     * If current renderer does not support canvas render buffers, NULL is returned. 

     * In unexpected error situations leave happens. 

     */ 

    CHuiCanvasRenderBuffer* CreateCachedRenderBufferL(const CHuiCanvasVisual& aUser, TSize aSizeHint = TSize(0,0));

    /**

     * Finds cached render buffer. Ownership is not transferred to the caller.  

     */ 

    CHuiCanvasRenderBuffer* FindCachedRenderBuffer(const CHuiCanvasVisual& aUser);

    /**

     * Releases render buffer of the given user. Render buffer is not

     * neccessarely deleted immediately, thus it may continue to be available in the cache.

     */ 

    void ReleaseCachedRenderBuffer(const CHuiCanvasVisual& aUser);

	/**

	 * This method releases all images and texts that are used by the given user. Images are not

	 * neccessarely deleted immediately,thus they may continue to be available in the cache.

	 */ 

    void ReleaseAllCachedEntries(const CHuiCanvasVisual& aUser);

	/**

	 * Called by the env when frame has been completed. 

	 */ 

    void AdvanceTime();

	/**

	 * Called when texture memory has run out. This method tries to release more texture memory.

	 */ 

    void HandleOutOfTextureMemory();

	/**

	 * Utility to create new (or reuse recylced) texture.

	 */ 

    CHuiTexture* CreateRecycledTextureL();

	/**

	 * Deletes (or moves to recycling) given texture.

	 */ 

    void DeleteRecycledTexture(CHuiTexture* aTexture);

    void EnableTouchCountCheck(TBool aEnable = ETrue);

    TBool IsTouchCountCheckEnabled();

private:

    void DeleteAllReleasedEntries(TBool aAllowKeepCached);        

    void FindUnusedImageEntries(RPointerArray<CHuiCanvasGraphicImage>& aIndexEntries);    

    void FindUnusedTextEntries(RPointerArray<CHuiCanvasTextImage>& aIndexEntries);

    void FindUnusedRenderBufferEntries(RPointerArray<CHuiCanvasRenderBufferImage>& aIndexEntries);

    void SelectPreservedUnusedImageEntries(RPointerArray<CHuiCanvasGraphicImage>& aIndexEntries);    

    void SelectPreservedUnusedTextEntries(RPointerArray<CHuiCanvasTextImage>& aIndexEntries);

    void SelectPreservedUnusedRenderBufferEntries(RPointerArray<CHuiCanvasRenderBufferImage>& aIndexEntries);

    void DeleteUnusedImageEntries(RPointerArray<CHuiCanvasGraphicImage>& aIndexEntries);

    void DeleteUnusedTextEntries(RPointerArray<CHuiCanvasTextImage>& aIndexEntries);

    void DeleteUnusedRenderBufferEntries(RPointerArray<CHuiCanvasRenderBufferImage>& aIndexEntries);

    void CalculateGraphicsMemoryUsage();    

    TInt CalculateUnusedCanvasTextureUsageInKbytes();

    TInt CalculateUnusedCanvasRenderBufferUsageInKbytes();

    TInt CalculateTotalCanvasRenderBufferUsageInKbytes();

    CHuiCanvasRenderBufferImage* ReUseReleasedRenderBuffer(TSize aSizehint);

    TBool IsLowMemoryStateEnabled() const;

private:

    /** Temp entry for doing quick search op */

    CHuiCanvasTextImage* iSearchedTextImageEntry;

    /** Temp entry for doing quick search op */

    CHuiCanvasGraphicImage* iSearchedGraphicImageEntry;

    /** Temp entry for doing quick search op */

    CHuiCanvasRenderBufferImage* iSearchedRenderBufferImageEntry;

    /** Cached images */

    RPointerArray<CHuiCanvasGraphicImage> iCachedImages;

    /** Cached texts */

    RPointerArray<CHuiCanvasTextImage>  iCachedTexts;

    /** Cached render buffers */

    RPointerArray<CHuiCanvasRenderBufferImage>  iCachedRenderBuffers;

    /** Flag to tell that there are unused images which should be possibly deleted */

    TBool iHasReleasedImages;

    /** Flag to tell that there are unused texts which should be possibly deleted */

    TBool iHasReleasedTexts;

    /** Flag to tell that there are unused render buffers which should be possibly deleted */

    TBool iHasReleasedRenderBuffers;

    /** Amount of texture memory reserved for unused texts */

    TInt iUnusedCanvasTextTextureCacheSizeInKBytes;

    /** Amount of texture memory reserved for unused images */

    TInt iUnusedCanvasImageTextureCacheSizeInKBytes;

    /** Amount of texture memory reserved for unused render buffers */

    TInt iUnusedCanvasRenderBufferCacheSizeInKBytes;

    /** Total amount of all hui textures are attempted (but not promised) to keep below this limit */

    TInt iMaxTextureMemoryInKBytes;

    /** Total amount of all render buffers are attempted (but not promised) to keep below this limit */

    TInt iMaxRenderBufferMemoryInKBytes;

    /** Texture recycling array */

    RPointerArray<CHuiTexture> iRecycledTextures;

    /** Rasterizer for texts */

    CHuiCanvasTextImageRasterizer* iTextImageRasterizer;

    /** Rasterizer for outline texts */

    CHuiCanvasTextImageRasterizer* iOutLineTextImageRasterizer;

    /** Rasterizer for image */

    CHuiCanvasGraphicImageRasterizer* iGraphicImageRasterizer;

    /** Rasterizer for combined image */

    CHuiCanvasCombinedGraphicImageRasterizer* iCombinedGraphicImageRasterizer;

    /** Canvas gc instance for internal use */

    CHuiCanvasGc* iCanvasGc;

    /** This controls the amount of cached textures, buffers, etc. */

    THuiMemoryLevel iMemoryLevel;

    /** RnD utils */

    TInt iEglProfiling;

	TBool iTouchCountCheckEnabled;

    };

#endif