--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/fontstore/inc/openfontsprivate.h	Fri Jun 04 10:37:54 2010 +0100
@@ -0,0 +1,454 @@
+/*
+* 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
+	};
+
+/**
+ @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;				
+	};
+/**
+ 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;
+    /** Pointer to next glyph that was added to the glyph cache.  This enables 
+     non-recursive deletion of the cache. This is only ever accessed from server
+     process, so can be a direct pointer, not an offset. */
+    COpenFontGlyphTreeEntry* iNext;
+
+private:
+	COpenFontGlyphTreeEntry(TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics)
+	 :	COpenFontGlyph(aCode, aGlyphIndex, aMetrics), iLeftOffset(0), iRightOffset(0),iNext(NULL){}
+
+	~COpenFontGlyphTreeEntry();
+	};
+
+/**
+ * Template for offset implementation of pointer to pointer
+ @internalComponent
+ */
+template<class T>
+class ROffsetArray
+    {
+public:
+    ROffsetArray();
+    TInt Create(RHeap* aHeap, TInt aCount);
+    void Close(RHeap* aHeap);
+    TInt Count() const;
+    T* operator[](TInt aIndex) const;
+    void SetAt(TInt aIndex, T* aEntry);
+private:
+    TInt iOffset;
+    TInt iCount;
+    };
+
+
+/**
+ 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),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:
+	TInt iGlyphTreeOffset;									// an offset to 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;	
+	};
+
+/**
+ @internalComponent
+ */
+
+class COpenFontSessionCacheEntry: public COpenFontGlyph
+	{
+public:
+	static COpenFontSessionCacheEntry* New(RHeap* aHeap, const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,
+										   const TOpenFontCharMetrics& aMetrics, const TDesC8& aBitmap);
+	inline const COpenFont* Font()const;
+
+private:
+	inline COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex, const TOpenFontCharMetrics& aMetrics);
+	~COpenFontSessionCacheEntry();
+public:
+    TInt iLastAccess;               // serial number of the last access to the glyph
+
+private: 
+    TInt iFontOffset;          // offset of the font that contains this glyph, (not owned by this class!)    
+	};
+
+/**
+ A glyph cache for a particular session.
+ Because session caches are not shared they can shrink as well as grow.
+
+ @internalComponent
+ */
+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);
+    ~COpenFontSessionCache();
+public:
+    TInt iSessionHandle;    
+    TInt iLastAccess;
+    ROffsetArray<COpenFontSessionCacheEntry> iEntryArray;
+    };
+
+/**
+ @internalComponent
+ */
+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;
+	};
+
+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'.
+    };
+
+
+// inline functions
+inline COpenFontSessionCacheEntry::COpenFontSessionCacheEntry(const COpenFont* aFont, TInt aCode, TInt aGlyphIndex,const TOpenFontCharMetrics& aMetrics) :
+    COpenFontGlyph(aCode, aGlyphIndex, aMetrics)
+    {
+    iFontOffset = aFont ? reinterpret_cast<TInt>(aFont) - reinterpret_cast<TInt>(this) : 0;
+    }
+
+
+inline const COpenFont* COpenFontSessionCacheEntry::Font() const
+    {
+    if (iFontOffset)
+        {
+        return reinterpret_cast<const COpenFont*> (PtrAdd(this, iFontOffset));
+        }
+    else
+        {
+        return NULL;
+        }
+    }
+
+#endif	// __OPENFONTSPRIVATE_H__