--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/coretoolkit/inc/huicanvastexturecache.h Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,474 @@
+/*
+* 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
+