/*

* 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;