--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/fontstore/inc/openfontsprivate.h	Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,574 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __OPENFONTS_PRIVATE_H__
+#define __OPENFONTS_PRIVATE_H__
+
+#include <e32hashtab.h>
+
+class COpenFontShaperCacheEntry;
+
+/* MSB is set to indicate a glyph code rather than a unicode value
+   This is used for extracting the code value */
+#define GLYPH_CODE(code) (code & 0x7fffffff)
+
+/** COpenFontFile owned container for extra data. May be extended without affecting Binary Compatibility.
+
+ @internalComponent
+ */
+
+class TOpenFontFileData
+	{
+public:
+	CFontStore* iFontStore;			// pointer to the CFontStore instance that loaded the COpenFontFile
+	};
+
+#ifdef FNTSTORE_SUPPORT_FMM
+/**
+ @internalComponent
+ */
+class COpenFontGlyph
+	{
+public:
+	COpenFontGlyph(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics):
+		iCode(aCode), iGlyphIndex(aGlyphIndex), iMetrics(aMetrics), iBitmapOffset(0) { }
+	
+	static COpenFontGlyph* NewL(RHeap* aHeap, TInt aCode, TInt aGlyphIndex,
+								const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+
+	static void Delete(RHeap* aHeap, COpenFontGlyph* aGlyph);	
+	TUint8* Bitmap() const;	
+
+	TInt iCode;						// the Unicode value of the character
+	TInt iGlyphIndex;				// the glyph index
+	TOpenFontCharMetrics iMetrics;	// the metrics	
+
+protected:
+	TBool SetBitmap(RHeap* aHeap, const TDesC8& aBitmap);
+	~COpenFontGlyph();
+	
+private:
+	// an offset from this COpenFontGlyph object to a pointer to the run-length-encoded bitmap, 
+	// calculated as (bitmapPointer)-(this)
+	TInt iBitmapOffset;				
+	};
+#else
+/**
+ @internalComponent
+ */
+class COpenFontGlyph
+	{
+public:
+	COpenFontGlyph(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics):
+		iCode(aCode), iGlyphIndex(aGlyphIndex), iMetrics(aMetrics), iBitmap(NULL) { }
+	
+	static COpenFontGlyph* NewL(RHeap* aHeap, TInt aCode, TInt aGlyphIndex,
+								const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+
+	static void Delete(RHeap* aHeap, COpenFontGlyph* aGlyph);
+
+	TInt iCode;						// the Unicode value of the character
+	TInt iGlyphIndex;				// the glyph index
+	TOpenFontCharMetrics iMetrics;	// the metrics
+	TUint8* iBitmap;				// the run-length-encoded bitmap
+
+protected:
+	TBool SetBitmap(RHeap* aHeap, const TDesC8& aBitmap);
+	~COpenFontGlyph();
+	};
+#endif // FNTSTORE_SUPPORT_FMM
+
+#ifdef FNTSTORE_SUPPORT_FMM
+/**
+ Binary tree of glyphs. Each glyph can have left and right child nodes which are added
+ depending on the value of their glyph code relative to the parent's glyph code.
+
+ @internalComponent
+ */
+class COpenFontGlyphTreeEntry: public COpenFontGlyph
+	{
+	friend class COpenFont;
+	
+public:
+	static COpenFontGlyphTreeEntry* New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex,
+										const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+
+private:
+	/** The left COpenFontGlyphTreeEntry from this entry. Represented by an offset from the
+	current heap base. Use COpenFont::ThisOffsetToPointer() to convert to a valid 
+	COpenFontGlyphTreeEntry pointer. */
+	TInt iLeftOffset; 
+	/** The right COpenFontGlyphTreeEntry from this entry. Represented by an offset from the
+	current heap base. Use COpenFont::ThisOffsetToPointer() to convert to a valid 
+	COpenFontGlyphTreeEntry pointer. */
+	TInt iRightOffset;
+
+private:
+	COpenFontGlyphTreeEntry(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics)
+	 :	COpenFontGlyph(aCode, aGlyphIndex, aMetrics), iLeftOffset(0), iRightOffset(0) {}
+
+	~COpenFontGlyphTreeEntry();
+	};
+#else
+/**
+ binary tree of glyphs
+
+ @internalComponent
+ */
+class COpenFontGlyphTreeEntry: public COpenFontGlyph
+	{
+public:
+	static COpenFontGlyphTreeEntry* New(RHeap* aHeap, TInt aCode, TInt aGlyphIndex,
+										const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+
+	COpenFontGlyphTreeEntry* iLeft;		// pointer to left node in tree
+	COpenFontGlyphTreeEntry* iRight;	// pointer to right node in tree
+	COpenFontGlyphTreeEntry* iNext;		// pointer to next glyph in the list; so that the cache can be deleted non-recursively
+
+private:
+	COpenFontGlyphTreeEntry(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics)
+	 :	COpenFontGlyph(aCode, aGlyphIndex, aMetrics), iLeft(NULL), iRight(NULL), iNext(NULL) { }
+	
+	~COpenFontGlyphTreeEntry();
+	};
+#endif // FNTSTORE_SUPPORT_FMM
+
+#ifdef FNTSTORE_SUPPORT_FMM
+/**
+ RArray for storing offsets to COpenFontGlyphTreeEntry objects. Stores each
+ COpenFontGlyphTreeEntry as an offset from the "this" pointer of this object.
+ Allows glyph entries to be added, accessed and deleted from the glyph array
+ from different processes.  
+ 
+ @internalComponent
+ */
+class RArrayGlyphEntries : public RArray<TInt>
+	{
+public:
+	inline const COpenFontGlyphTreeEntry& operator[](TInt anIndex) const;
+	inline COpenFontGlyphTreeEntry& operator[](TInt anIndex);
+	TInt Append(COpenFontGlyphTreeEntry& anEntry);
+private:
+	inline const COpenFontGlyphTreeEntry* Entry(TInt anIndex) const;
+	inline COpenFontGlyphTreeEntry** EntryMemberOffSet() const;
+	inline TAny** EntryMember() const;
+private:
+	TInt iEntriesOffset;
+	};
+#endif // FNTSTORE_SUPPORT_FMM
+
+#ifdef FNTSTORE_SUPPORT_FMM
+/**
+ The per-font glyph cache. For now, just the members that used to be directly in
+ COpenFont. Now it is a private class it can be elaborated to do character-to-glyph-index
+ mapping when that is needed.
+
+ @internalComponent
+ */
+class COpenFontGlyphCache
+	{
+public:
+	COpenFontGlyphCache(): iGlyphTreeOffset(0), iGlyphCacheMemory(0), iShaperCacheSentinel(NULL), iShapingInfoCacheMemory(0), iNumberOfShaperCacheEntries(0) { }
+	TShapeHeader* SearchShaperCache(TInt aSessionHandle, TFontShapeFunctionParameters*& aParams);
+	TShapeHeader* Insert(TInt aSessionHandle, RHeap* aHeap, CShaper::TInput aInput, TShapeHeader* aShapeHeader, TInt& aAddedBytes);
+	TInt DeleteLeastRecentlyUsedEntry(RHeap* aHeap);
+	TBool ShaperCacheIsEmpty();
+	
+public:
+	TInt iGlyphTreeOffset;									// an offset to root of the glyph cache; a binary tree
+	TInt iGlyphCacheMemory;									// memory used by the glyph tree in bytes
+	COpenFontShaperCacheEntry* iShaperCacheSentinel;
+	TInt iShapingInfoCacheMemory;
+	TInt iNumberOfShaperCacheEntries;
+	RArrayGlyphEntries iGlyphArray;
+	};
+#else
+/**
+ The per-font glyph cache. For now, just the members that used to be directly in
+ COpenFont. Now it is a private class it can be elaborated to do character-to-glyph-index
+ mapping when that is needed.
+
+ @internalComponent
+ */
+class COpenFontGlyphCache
+	{
+public:
+	COpenFontGlyphCache(): iGlyphTree(NULL), iGlyphCacheMemory(0), iGlyphList(NULL), iShaperCacheSentinel(NULL), iShapingInfoCacheMemory(0), iNumberOfShaperCacheEntries(0) { }
+	TShapeHeader* SearchShaperCache(TInt aSessionHandle, TFontShapeFunctionParameters*& aParams);
+	TShapeHeader* Insert(TInt aSessionHandle, RHeap* aHeap, CShaper::TInput aInput, TShapeHeader* aShapeHeader, TInt& aAddedBytes);
+	TInt DeleteLeastRecentlyUsedEntry(RHeap* aHeap);
+	TBool ShaperCacheIsEmpty();
+	
+public:
+	COpenFontGlyphTreeEntry* iGlyphTree;					// the root of the glyph cache; a binary tree
+	TInt iGlyphCacheMemory;									// memory used by the glyph tree in bytes
+	COpenFontGlyphTreeEntry* iGlyphList;					// the glyphs, organized as a list
+	COpenFontShaperCacheEntry* iShaperCacheSentinel;
+	TInt iShapingInfoCacheMemory;
+	TInt iNumberOfShaperCacheEntries;
+	};
+#endif // FNTSTORE_SUPPORT_FMM
+
+/**
+ @internalComponent
+ */
+#ifdef FNTSTORE_SUPPORT_FMM
+class COpenFontSessionCacheEntry: public COpenFontGlyph
+	{
+public:
+	static COpenFontSessionCacheEntry* New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,
+										   const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+	inline COpenFont* Font()const;
+
+private:
+	COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics):
+		COpenFontGlyph(aCode, aGlyphIndex, aMetrics)
+		, iFontOffset(reinterpret_cast<TInt>(aFont) - reinterpret_cast<TInt>(this))	
+		    { }
+	~COpenFontSessionCacheEntry();
+public:
+    TInt iLastAccess;               // serial number of the last access to the glyph
+
+private: 
+    const TInt iFontOffset;          // offset of the font that contains this glyph, (not owned by this class!)    
+	};
+
+#else
+class COpenFontSessionCacheEntry: public COpenFontGlyph
+    {
+public:
+    static COpenFontSessionCacheEntry* New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,
+                                           const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+
+private:
+    COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics):
+        COpenFontGlyph(aCode, aGlyphIndex, aMetrics), iFont(aFont) { }
+    ~COpenFontSessionCacheEntry();
+public:
+    const COpenFont* iFont;         // the font that contains this glyph, (not owned by this class!)
+    TInt iLastAccess;               // serial number of the last access to the glyph
+    };
+   
+#endif    //FNTSTORE_SUPPORT_FMM
+
+/**
+ A glyph cache for a particular session.
+ Because session caches are not shared they can shrink as well as grow.
+
+ @internalComponent
+ */
+#ifdef FNTSTORE_SUPPORT_FMM
+class COpenFontSessionCache
+    {
+public:
+    static COpenFontSessionCache* NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries);
+    void Delete(RHeap* aHeap);
+    
+    TInt SessionHandle() { return iSessionHandle; }
+    const COpenFontGlyph* Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex);
+    void Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex);
+    inline TInt* Entry()const;
+    inline COpenFontSessionCacheEntry* ToCOpenFontSessionCacheEntryPointer(TInt aOffset)const;
+    
+private:
+    COpenFontSessionCache(TInt aSessionHandle, TInt aEntries);
+    ~COpenFontSessionCache();
+public:
+    TInt iSessionHandle;    
+    TInt iEntries;
+    TInt iLastAccess;
+private:    
+    TInt iEntryOffset;    // Offset of the pointer to an offset array which is of COpenFontSessionCacheEntry*    
+    };
+#else
+class COpenFontSessionCache
+	{
+public:
+	static COpenFontSessionCache* NewL(RHeap* aHeap, TInt aSessionHandle, TInt aEntries);
+	void Delete(RHeap* aHeap);
+	
+	TInt SessionHandle() { return iSessionHandle; }
+	const COpenFontGlyph* Glyph(const COpenFont* aFont, TInt aCode, TInt& aIndex);
+	void Insert(RHeap* aHeap, COpenFontSessionCacheEntry* aEntry, TInt aIndex);
+
+private:
+	COpenFontSessionCache(TInt aSessionHandle, TInt aEntries);
+	~COpenFontSessionCache();
+public:
+	TInt iSessionHandle;
+	TInt iEntries;
+	TInt iLastAccess;
+	COpenFontSessionCacheEntry** iEntry;
+	};
+#endif //FNTSTORE_SUPPORT_FMM
+/**
+ @internalComponent
+ */
+#ifdef FNTSTORE_SUPPORT_FMM
+class COpenFontSessionCacheListItem
+	{
+public:
+	COpenFontSessionCacheListItem(COpenFontSessionCache* aCache);
+
+	COpenFontSessionCacheListItem* Next();
+	void SetNext(COpenFontSessionCacheListItem* aNext);
+	COpenFontSessionCache* Cache(); 
+
+	void Delete(RHeap* aHeap);
+private:
+	~COpenFontSessionCacheListItem();
+private:
+	TInt iNextOffset;
+	TInt iCacheOffset;
+	};
+#else
+class COpenFontSessionCacheListItem
+	{
+public:
+	COpenFontSessionCacheListItem(COpenFontSessionCache* aCache): iNext(NULL), iCache(aCache) { }
+	void Delete(RHeap* aHeap);
+private:
+	~COpenFontSessionCacheListItem();
+public:
+	COpenFontSessionCacheListItem* iNext;	// the next cache in the list
+	COpenFontSessionCache* iCache;			// the cache if non-null;
+	};	
+#endif // FNTSTORE_SUPPORT_FMM
+
+
+class TFontTableGlyphOutlineCacheMemMonitor
+    {
+public:
+    TFontTableGlyphOutlineCacheMemMonitor();
+    void Inc(TInt aBytes);
+    void Dec(TInt aBytes);
+    TInt GetMemUsage();
+private:
+    TInt iBytes;
+    };
+
+struct TCacheUserInfo {
+    TInt iSessionHandle;
+    TInt iRefCount;
+    TCacheUserInfo(TInt aSessionHandle, TInt aRefCount = 0): 
+            iSessionHandle(aSessionHandle), iRefCount(aRefCount) { } 
+};
+
+class CFontTableCache;
+
+class CFontTableCacheItem
+    {
+friend class CFontTableCache ;
+
+public:
+    CFontTableCacheItem(TUid &aFileUid, const TUint32 aTag, 
+            TInt aOffset, TInt aLength);
+    ~CFontTableCacheItem(); 
+
+    TInt DecRefCount(TInt aSessionHandle);
+    TInt IncRefCount(TInt aSessionHandle);
+
+    TBool HasOutstandingRefCount();
+    TInt FindUser(TInt aSessionHandle, TInt *id);
+    
+#ifdef _DEBUG
+    void SetUser(RPointerArray<TCacheUserInfo> users)
+        {
+        TInt len = users.Count();
+        for( TInt i = 0; i < len ; i++ )
+            {
+            iUsers.Append(users[i]);
+            }
+        }    
+#endif
+    
+private:
+    CFontTableCacheItem(const CFontTableCacheItem &); // disallow copy construction.
+    CFontTableCacheItem& operator =(const CFontTableCacheItem &); // disallow assignment.
+    
+    TUid iFileUid; 
+    TUint32 iTag; 
+ 
+
+    TInt iOffset;
+    TInt iLength; 
+    RPointerArray<TCacheUserInfo> iUsers;
+    }; 
+
+
+class CFontTableCache 
+    {
+public:
+    CFontTableCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    ~CFontTableCache();
+    TInt Append(TUid aFileUid, TUint32 aTag, 
+            TAny*& aContent, TInt aLength);
+    TInt Find(TUid aFileUid, TUint32 aTag, TAny*& aContent, TInt& aLength, TInt* id);
+    TInt IncRefCount(TUid FileUid, TUint32 aTag, TInt aSessionHandle);
+    TInt DecRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle);
+    TBool HasOutstandingRefCount();
+    TBool HasOutstandingRefCountWithUid(TUid aFileUid);  
+    void CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+    void CleanupCacheOnOpenFontFileRemoval(COpenFontFile*);
+#ifdef _DEBUG    
+    void SetFontItem(RPointerArray<CFontTableCacheItem> cacheItems)
+        {
+        TInt len = cacheItems.Count();
+        for(TInt i = 0; i < len; i++)
+            {
+            iCacheItems.Append(cacheItems[i]);
+            }
+        }
+#endif   
+    
+private:
+    CFontTableCache(const CFontTableCache &); // no copy construction.
+    CFontTableCache& operator =(const CFontTableCache &); // no assignment.
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+#endif
+    
+    TFontTableGlyphOutlineCacheMemMonitor &iCacheMemMon;
+    RHeap *iHeap;
+    RPointerArray<CFontTableCacheItem> iCacheItems;
+    };
+
+
+class TUnhintedOutlineCache;
+
+class TUnhintedOutlineId 
+    {
+public:
+    TUnhintedOutlineId(TUid aFileUid, TInt aFaceIndex, TUint aId);
+    TUid iFileUid;
+    TInt iFaceIndex;
+    TUint iId;
+    };
+
+class COutlineCacheItem {
+friend class CUnhintedOutlineCache;
+friend class CHintedOutlineCache;
+    
+public:
+    COutlineCacheItem(TInt aOffset, TInt aLength);
+    ~COutlineCacheItem() ;
+
+    TInt DecRefCount(TInt aSessionHandle);
+    TInt IncRefCount(TInt aSessionHandle);
+#ifdef _DEBUG
+    void SetUser(RPointerArray<TCacheUserInfo> users)
+        {
+        TInt len = users.Count();
+        for( TInt i = 0; i < len ; i++ )
+            {
+            iUsers.Append(users[i]);
+            }
+        }    
+#endif
+ 
+private:
+    TInt FindUser(TInt aSessionHandle, TInt *id);
+        
+
+    TInt iOffset;
+    TInt iLength;
+    RPointerArray<TCacheUserInfo> iUsers;
+};    
+
+class CUnhintedOutlineCache {
+public:
+    CUnhintedOutlineCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    TInt Find(const TUnhintedOutlineId &aOutlineId, TAny*& aData, TInt& aLength);
+    TInt IncRefCount(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt DecRefCount(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt CacheUnhintedOutline(const TUnhintedOutlineId& aOutlineId, 
+            TAny * const aData, const TInt aLength, TAny*& aOutline, TInt &aLen);
+    TInt CleanupCacheOnOpenFontFileRemoval(COpenFontFile* aFontFile);
+    TInt CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+#endif
+    ~CUnhintedOutlineCache();
+    
+#ifdef _DEBUG
+    void SetUnHintedItem(TUnhintedOutlineId id, COutlineCacheItem* item)
+        {
+        iItemIdMap.Insert(id, item);
+        }
+#endif
+    
+private:
+    // disallow assignment and copy-construction
+    CUnhintedOutlineCache(const CUnhintedOutlineCache &); 
+    CUnhintedOutlineCache& operator =(const CUnhintedOutlineCache &);
+    
+    static TUint32 IdHash(const TUnhintedOutlineId& aOutlineId);
+    static TBool IdIdentity(const TUnhintedOutlineId& id1, const TUnhintedOutlineId& id2);
+    
+    TFontTableGlyphOutlineCacheMemMonitor& iCacheMemMon;
+    RHeap* iHeap; 
+    RHashMap<TUnhintedOutlineId, COutlineCacheItem*> iItemIdMap; // map the identity to an index in 'iCacheItems'.
+};
+
+class CHintedOutlineCache;
+
+class THintedOutlineId 
+    {
+public:
+    THintedOutlineId(COpenFont* aFont, TUint aId);
+    COpenFont *iFont;
+    TUint iId;
+    };
+
+
+class CHintedOutlineCache {
+public:
+    CHintedOutlineCache(RHeap* aHeap, TFontTableGlyphOutlineCacheMemMonitor& aMon);
+    TInt Find(const THintedOutlineId& aOutlineId, TAny*& aData, TInt& aLength);
+    TInt IncRefCount(const THintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt DecRefCount(const THintedOutlineId& aOutlineId, TInt aSessionHandle);
+    TInt CacheHintedOutline(const THintedOutlineId& aOutlineId, 
+            TAny* aData, TInt aLength, TAny*& aOutline, TInt& aLen);
+    TInt CleanupCacheOnOpenFontRemoval(COpenFont* aFont);
+    TInt CleanupCacheOnFbsSessionTermination(TInt aSessionHandle);
+#ifdef _DEBUG
+    TInt GetCacheState(const char *func);
+    void SetHintedItem(THintedOutlineId id, COutlineCacheItem* item)
+        {
+        iItemIdMap.Insert(id, item);
+        }
+    RHashMap<THintedOutlineId, COutlineCacheItem*> GetHintedMap()
+    {
+    return iItemIdMap;
+    }
+#endif
+    
+private:
+    // disallow assignment and copy-construction
+    CHintedOutlineCache(const CHintedOutlineCache &); 
+    CHintedOutlineCache& operator =(const CHintedOutlineCache &);
+    static TUint32 IdHash(const THintedOutlineId& aOutlineId);
+    static TBool IdIdentity(const THintedOutlineId& id1, const THintedOutlineId& id2);
+        
+    TFontTableGlyphOutlineCacheMemMonitor& iCacheMemMon;
+    RHeap* iHeap; 
+    RHashMap<THintedOutlineId, COutlineCacheItem*> iItemIdMap; // map the identity to an index in 'iCacheItems'.
+    };
+
+
+#endif	// __OPENFONTSPRIVATE_H__