diff -r 000000000000 -r 1fb32624e06b fontservices/fontstore/inc/openfontsprivate.h --- /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 + +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 + { +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(aFont) - reinterpret_cast(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 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 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 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 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 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 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 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 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 iItemIdMap; // map the identity to an index in 'iCacheItems'. + }; + + +#endif // __OPENFONTSPRIVATE_H__