/*

 * Copyright (c) 1995-2010 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: 

 *

 */

 #include <e32hal.h>

 #include <hal.h>

 #include <s32file.h>

 #include <graphics/shapeimpl.h>

 #include <fntstore.h>

 #include "FNTBODY.H"

 #include "FNTSTD.H"

 #include <graphics/shaperparams.h>

 #define DO_LOADFONT_OPTIMIZATION 1

 #include <linkedfonts.h>

 #include "linkedfontsprivate.h"

 #include "openfontsprivate.h"

 #include <openfontlinkedtypefaceelementspec.h>

 #include <graphics/openfontlinkedtypefaceextension.h>

 #include <graphics/openfontlinkedtypefacespecification.h>

 #include <graphics/openfontrasterizer.h>

 #include <graphics/openfontconstants.h>

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "FNTSTORETraces.h"

 #endif

 static const TUint32 KOutlineGlyphIdHashMask = 0x0000ffff;

 static const TUint32 KOutlineFileUidHashMask = 0x00ff0000;

 static const TUint32 KOutlineFaceIndexHashMask = 0x0f000000;

 static const TUint32 KOutlineFontPtrHashMask = 0x0fff0000;

 // uncomment to enable some verbose debug prints

 //#define VERBOSE_DEBUG 1

 /**  These constants set the default pixel width and height, in Twips x1000.

  Hal Data information overrides this if it is available. EDisplayXPixels & EDisplayXTwips, 

  EDisplayYPixels & EDisplayYTwips values are required respectively.

  (11860 is approx equivalent to 120 pixels per inch.)

 @internalComponent

 */

 const TInt KDefaultPixelWidthInTwips = 11860;

 const TInt KDefaultPixelHeightInTwips = 11860;

 // default granularity for arrays

 const TInt KDefaultArrayGranularity = 8;

 /* Maximum height of a character bitmap. When font height in pixel is 1024, each 

 character bitmap is equal to (roughly) 1024 x 1024 x 8 bits/pixel = 1 MB.

 @internalComponent

 */

 const TInt KMaxFontHeightInPixels = 1024;

 /* Minimum height of font in pixels that can be displayed on the screen.

 @internalComponent

 */

 const TInt KMinFontHeightInPixels = 2;

 /**

 The arbitrary list of sizes, in points, returned for scaleable fonts.

 We can't return 2^32 - 1 sizes, or something that reflect the fact

 that any size is okay, because a UI will probably try to create a listbox containing all the sizes.

 Array stored in Twips as that is the only form of the value currently used.

 @internalComponent

 */

 #define POINTSIZE_IN_TWIPS(p)	((p) * 20)

 const TInt gOpenFontSizeInTwipsArray[] =

 	{

 	// 4pt-18pt in steps of 1pt (15 sizes)

 	POINTSIZE_IN_TWIPS(4), POINTSIZE_IN_TWIPS(5), POINTSIZE_IN_TWIPS(6),

 	POINTSIZE_IN_TWIPS(7), POINTSIZE_IN_TWIPS(8), POINTSIZE_IN_TWIPS(9),

 	POINTSIZE_IN_TWIPS(10), POINTSIZE_IN_TWIPS(11), POINTSIZE_IN_TWIPS(12),

 	POINTSIZE_IN_TWIPS(13), POINTSIZE_IN_TWIPS(14), POINTSIZE_IN_TWIPS(15),

 	POINTSIZE_IN_TWIPS(16), POINTSIZE_IN_TWIPS(17), POINTSIZE_IN_TWIPS(18),

 	// 20pt-36pt in steps of 2pt (9 sizes)

 	POINTSIZE_IN_TWIPS(20), POINTSIZE_IN_TWIPS(22), POINTSIZE_IN_TWIPS(24),

 	POINTSIZE_IN_TWIPS(26), POINTSIZE_IN_TWIPS(28), POINTSIZE_IN_TWIPS(30),

 	POINTSIZE_IN_TWIPS(32), POINTSIZE_IN_TWIPS(34), POINTSIZE_IN_TWIPS(36),

 	// 40pt-72pt in steps of 4pt (9 sizes)

 	POINTSIZE_IN_TWIPS(40), POINTSIZE_IN_TWIPS(44), POINTSIZE_IN_TWIPS(48),

 	POINTSIZE_IN_TWIPS(52), POINTSIZE_IN_TWIPS(56), POINTSIZE_IN_TWIPS(60),

 	POINTSIZE_IN_TWIPS(64), POINTSIZE_IN_TWIPS(68), POINTSIZE_IN_TWIPS(72),

 	// 80pt-144pt in steps of 8pt (9 sizes)

 	POINTSIZE_IN_TWIPS(80), POINTSIZE_IN_TWIPS(88), POINTSIZE_IN_TWIPS(96),

 	POINTSIZE_IN_TWIPS(104), POINTSIZE_IN_TWIPS(112), POINTSIZE_IN_TWIPS(120),

 	POINTSIZE_IN_TWIPS(128), POINTSIZE_IN_TWIPS(136), POINTSIZE_IN_TWIPS(144)

 	};

 const TInt KOpenFontSizeArrayCount = sizeof(gOpenFontSizeInTwipsArray) / sizeof(gOpenFontSizeInTwipsArray[0]);

 /**

 @internalTechnology

  The folder used to store linked fonts; the character represents the system drive

  location and the descriptor contains the private path of fbserv.

  */

 _LIT(KLinkedFontFileFolder, "%c:%Slfonts\\");

 /**

 @internalTechnology

  The folder used to store updated linked fonts; the descriptor should be formatted

  with the formatted version of KLinkedFontFileFolder. Files will be moved from this

  folder to KLinkedFontFileFolder at boot time before the font loading procedure.

  */

 _LIT(KLinkedFontFileTempFolder, "update\\");

 /**

 The font search string. The Y: directory prefix forces the search to 

 start with drive Y:. The drives will be searched in the order Y: to A: then Z:

 */

 _LIT(KFBSERVFontDirSecure, "y:\\resource\\fonts\\");

 /**The maximum length of the linked font folder path*/

 const TInt KMaxLinkedFontPathLength = 36;

 /**The maximum length of a private path*/

 const TInt KMaxPrivatePathLength = 19;

 /** Container for TTypefaceSupport that describes an Open Font family.

 There is an implicit assumption that all fonts in the family will have the same attributes

 as the first instance found.  E.g. that the range of font heights is the same. 

 An array of pointers to the COpenFontFile file objects that hold fonts in this family

 also provides reference counting for the object.

 @internalComponent

 */

 NONSHARABLE_CLASS(CTypefaceSupportInfo) : public CBase

 	{

 public:

 	CTypefaceSupportInfo();

 	inline TInt AddFontFilePtr(COpenFontFile* aOpenFontFile);

 	inline TInt AddUniqueFontFilePtr(COpenFontFile* aOpenFontFile,const TOpenFontFaceAttrib& aFaceAttrib);

 	inline TInt FindFontFilePtr(COpenFontFile* aOpenFontFile);

 	inline TBool RemoveFontFilePtr(TInt aIndex);

 	void SetTypefaceInfo(const TOpenFontFaceAttrib& aFaceAttrib, TInt aMinHeightInTwips);

 	inline const TTypefaceSupport* TypefaceSupport() const;

 	inline TInt NearestPointSizeIndex() const;

 	static TInt CompareFontNames(const CTypefaceSupportInfo& aTypeface1, const CTypefaceSupportInfo& aTypeface2);

 	~CTypefaceSupportInfo();

 public:

 	TTypefaceSupport iSupport;

 	// pointers back to the COpenFontFile object which has one or more typefaces in this family

 	RPointerArray<COpenFontFile> iOpenFontFilePtrArray;

 	// nearest standard point size index;

 	TInt iNearestPointSizeIndex;

 	};

 /** helper class used with the cleanup stack

 @internalComponent

 */

 class TCleanupRemoveFontFile

 	{

 public:

 	inline TCleanupRemoveFontFile(CFontStore* aFontStore, TUid aFontUid);

 public:

 	CFontStore* iFontStore;

 	TUid iFontUid;

 	};

 // declare static functions

 static TInt MatchFontSpecsInPixels(const TOpenFontSpec& aCandidateFontSpec,

 	const TOpenFontSpec& aIdealFontSpec, TInt aCandidateMaxHeight = 0, TInt aIdealMaxHeight = 0);

 static void ReadFromFileL(RFile& aFile, TDes8& aDes, TInt aLength);

 static TUint TtfTableTagFromBufferL(TDes8& aDes);

 #ifdef _DEBUG

 static TUint32 StartTiming(void);

 static TUint32 FinishTimingL(TUint32 startTime);

 #endif

 static TBool FileIsOnZ(TParse& aFileName);

 static TBool FileIsInList(TParse& aFileName, RArray<TParse>& aList);

 /** Helper function for converting a pointer to an offset from the passed

 heap base. Use OffsetToPointer() to convert the returned offset back to a

 useable pointer.

 @param aAny A pointer to be converted to an offset.

 @param aHeapBase The heap base of the current process.

 @return An offset representing the passed pointer that can be converted

 back to a pointer using the function OffsetToPointer(). 

 @see OffsetToPointer()

  */

 LOCAL_C TInt PointerToOffset(const TAny* aAny, TUint8* aHeapBase)

     {

     if (aAny && aHeapBase)

         {

         return reinterpret_cast<TInt>(aAny) - reinterpret_cast<TInt>(aHeapBase);

         }

     return 0;

     }

 /** Helper function for converting an offset (that was calculated using

 PointerToOffset()) back to a pointer relative to the passed heap base.

 @param aOffset The offset to be converted to a pointer.

 @param aHeapBase The heap base of the current process.

 @return A pointer relative to the passed heap base.

 @see PointerToOffset()

  */

 LOCAL_C TAny* OffsetToPointer(TInt aOffset, TUint8* aHeapBase)

     {

     if (aOffset && aHeapBase)

         {

         return reinterpret_cast<TAny*>(aOffset + reinterpret_cast<TInt>(aHeapBase));

         }

     return NULL;

     }

 // CTypefaceSupportInfo

 CTypefaceSupportInfo::CTypefaceSupportInfo()

 	{

 	}

 CTypefaceSupportInfo::~CTypefaceSupportInfo()

 	{ // no ownership of font files, so just Close the array

 	iOpenFontFilePtrArray.Close();

 	}

 /** Add a back pointer to an Open Font file, in sorted order.

 @param aOpenFontFile font file that has a typeface in this family.

 @return KErrNone if added, KErrAlreadyExists if file is already referenced, or KErrNoMemory.

 @internalComponent

 */

 TInt CTypefaceSupportInfo::AddFontFilePtr(COpenFontFile* aOpenFontFile)

 	{

 	return iOpenFontFilePtrArray.InsertInAddressOrder(aOpenFontFile);

 	}

 /** Add a back pointer to an Open Font file, in sorted order, but only if the font details are unique.

 @param aOpenFontFile font file that has a typeface in this family.

 @return KErrNone if added, KErrInUse if another file already defines this, KErrAlreadyExists if file is already referenced, or KErrNoMemory.

 @internalComponent

 */

 TInt CTypefaceSupportInfo::AddUniqueFontFilePtr(COpenFontFile* aOpenFontFile,const TOpenFontFaceAttrib& aFaceAttrib)

 	{

 #ifdef _DEBUG	

 	_LIT(KLoadedFont, "TypefaceSupport: already loaded font: %S\n");

 #endif

 	TPtrC findName=aFaceAttrib.FullName();

 	for (TInt i=0,maxi=iOpenFontFilePtrArray.Count();i<maxi;i++)

 		{	//Do any of the fonts already registered with this family already provide this specific font?

 		COpenFontFile* cmpFont=iOpenFontFilePtrArray[i];

 		if (cmpFont==aOpenFontFile)

 			{   //Another specific font in this font file has already been added to this family

 				//InsertInAddressOrder would detect this.

 #ifdef _DEBUG

 				RDebug::Print(KLoadedFont, &findName);

 #endif

 				return KErrAlreadyExists;	

 			}

 		else

 			{

 			for (TInt j=0,maxj=cmpFont->FaceCount();j<maxj;j++)

 				{	//The expectation is that open fonts will only have 1 face per file, so this loop is 1-pass generally.

 				const TOpenFontFaceAttrib& cmpFace=cmpFont->FaceAttrib(j);

 				TPtrC cmpName=cmpFace.FullName();

 				if (cmpName==findName)

 					{

 #ifdef _DEBUG

 					RDebug::Print(KLoadedFont, &findName);

 #endif

 					return KErrInUse;

 					}

 				}

 			}

 		}

 	return iOpenFontFilePtrArray.InsertInAddressOrder(aOpenFontFile);

 	}

 /** Check font family for back pointer to an Open Font file.

 @param aOpenFontFile font file that may have a typeface in this family.

 @return KErrNotFound or the index of pointer

 @internalComponent

 */

 TInt CTypefaceSupportInfo::FindFontFilePtr(COpenFontFile* aOpenFontFile)

 	{

 	return iOpenFontFilePtrArray.FindInAddressOrder(aOpenFontFile);

 	}

 /** Remove a font file back pointer.

 @param aIndex the index of pointer, from FindFontFilePtr()

 @return ETrue if there are no more implementations of the font family

 @internalComponent

 */

 TBool CTypefaceSupportInfo::RemoveFontFilePtr(TInt aIndex)

 	{

 	iOpenFontFilePtrArray.Remove(aIndex);

 	return iOpenFontFilePtrArray.Count() == 0;

 	}

 /** Set the details of the typeface family.

 @param aFaceAttrib typeface to parameterise.

 @internalComponent

 */

 void CTypefaceSupportInfo::SetTypefaceInfo(const TOpenFontFaceAttrib& aFaceAttrib, TInt aMinHeightInTwips)

 	{

 	iSupport.iTypeface.iName = aFaceAttrib.ShortFamilyName();

 	iSupport.iTypeface.SetIsProportional(!aFaceAttrib.IsMonoWidth());

 	iSupport.iTypeface.SetIsSerif(aFaceAttrib.IsSerif());

 	iSupport.iTypeface.SetIsSymbol(aFaceAttrib.IsSymbol());

 	// Find minimum size in twips then find the next higher standard size.

 	iSupport.iMinHeightInTwips = aMinHeightInTwips;

 	TInt fontSizeIndex = 0;

 	for (; fontSizeIndex < KOpenFontSizeArrayCount; ++fontSizeIndex)

 		{

 		const TInt KMinHeightInTwips = gOpenFontSizeInTwipsArray[fontSizeIndex];

 		if (aMinHeightInTwips <= KMinHeightInTwips)

 			{

 			aMinHeightInTwips = KMinHeightInTwips;

 			break;

 			}

 		}

 	iNearestPointSizeIndex = fontSizeIndex;

 	iSupport.iMaxHeightInTwips = Max(gOpenFontSizeInTwipsArray[KOpenFontSizeArrayCount - 1], iSupport.iMinHeightInTwips);

 	iSupport.iNumHeights = Max(1,KOpenFontSizeArrayCount - iNearestPointSizeIndex);

 	iSupport.iIsScalable = TRUE;

 	}

 /** Get the details of the typeface family.

 @internalComponent

 */

 const TTypefaceSupport* CTypefaceSupportInfo::TypefaceSupport() const

 	{

 	return &iSupport;

 	}

 /** Get the Nearest Standard Point Size Index.

 @internalComponent

 */

 TInt CTypefaceSupportInfo::NearestPointSizeIndex() const

 	{

 	return iNearestPointSizeIndex;

 	}

 // for InsertInOrder

 TInt CTypefaceSupportInfo::CompareFontNames(const CTypefaceSupportInfo& aTypeface1, const CTypefaceSupportInfo& aTypeface2)

 	{

 	return aTypeface1.iSupport.iTypeface.iName.CompareF(aTypeface2.iSupport.iTypeface.iName);

 	}

 // TCleanupRemoveFontFile

 TCleanupRemoveFontFile::TCleanupRemoveFontFile(CFontStore* aFontStore, TUid aFontUid) :

 	iFontStore(aFontStore), iFontUid(aFontUid)

 	{

 	}

 TBitmapFontCharacterOffset::TBitmapFontCharacterOffset()

  :	iBitmapOffset(0)

 	{}

 void TBitmapFontCharacterOffset::InternalizeL(RReadStream& aStream)

 	{

 	iBitmapOffset = aStream.ReadUint16L();

 	};

 EXPORT_C TCharacterMetrics::TCharacterMetrics()

  :	iAscentInPixels(0),

 	iHeightInPixels(0),

 	iLeftAdjustInPixels(0),

 	iMoveInPixels(0),

 	iRightAdjustInPixels(0)

 	{

 	}

 TBitmapFontCharacterMetrics::TBitmapFontCharacterMetrics()

  :	iAscentInPixels(0),

 	iHeightInPixels(0),

 	iLeftAdjustInPixels(0),

 	iMoveInPixels(0),

 	iRightAdjustInPixels(0)

 	{

 	}

 void TBitmapFontCharacterMetrics::InternalizeL(RReadStream& aStream)

 	{

 	iAscentInPixels = aStream.ReadInt8L();

 	iHeightInPixels = aStream.ReadInt8L();

 	iLeftAdjustInPixels = aStream.ReadInt8L();

 	iMoveInPixels = aStream.ReadInt8L();

 	iRightAdjustInPixels = aStream.ReadInt8L();

 	}

 /** Constructor. */

 EXPORT_C TAlgStyle::TAlgStyle()

  :	iBaselineOffsetInPixels(0),

 	iFlags(0),

 	iWidthFactor(1),

 	iHeightFactor(1)

 	{

 	}

 /** Sets whether the font is bold.

 @param aIsBold ETrue if the font is bold; otherwise EFalse. */

 EXPORT_C void TAlgStyle::SetIsBold(TBool aIsBold)

 	{

 	if (aIsBold)

 		iFlags |= EBold;

 	else

 		iFlags &= ~EBold;

 	}

 /** Sets whether the font is italic.

 @param aIsItalic ETrue if the font is italic; otherwise EFalse. */

 EXPORT_C void TAlgStyle::SetIsItalic(TBool aIsItalic)

 	{

 	if (aIsItalic)

 		iFlags |= EItalic;

 	else

 		iFlags &= ~EItalic;

 	}

 /** Sets whether the font is mono width - i.e. all characters have the same width.

 @param aIsMono ETrue if the font is mono width; otherwise EFalse. */

 EXPORT_C void TAlgStyle::SetIsMono(TBool aIsMono)

 	{

 	if (aIsMono)

 		iFlags|=EMono;

 	else

 		iFlags&=~EMono;

 	}

 /** Sets the width factor.

 @param aWidthFactor A width factor. */

 EXPORT_C void TAlgStyle::SetWidthFactor(TInt aWidthFactor)

 	{

 	iWidthFactor=(TInt8) aWidthFactor;

 	}

 /** Sets the height factor.

 @param aHeightFactor A height factor. */

 EXPORT_C void TAlgStyle::SetHeightFactor(TInt aHeightFactor)

 	{

 	iHeightFactor=(TInt8) aHeightFactor;

 	}

 /** Returns whether the font is bold.

 @return ETrue if the font is bold; otherwise EFalse. */

 EXPORT_C TBool TAlgStyle::IsBold() const

 	{

 	return iFlags&EBold;

 	}

 /** Returns whether the font is italic.

 @return ETrue if the font is italic; otherwise EFalse. */

 EXPORT_C TBool TAlgStyle::IsItalic() const

 	{

 	return iFlags&EItalic;

 	}

 /** Returns whether the font is mono - i.e. all characters have the same width.

 @return ETrue if the font is mono; otherwise EFalse. */

 EXPORT_C TBool TAlgStyle::IsMono() const

 	{

 	return iFlags&EMono;

 	}

 /** Returns the width factor.

 @return A width factor. */

 EXPORT_C TInt TAlgStyle::WidthFactor() const

 	{

 	return iWidthFactor;

 	}

 /** Returns the height factor.

 @return A height factor. */

 EXPORT_C TInt TAlgStyle::HeightFactor() const

 	{

 	return iHeightFactor;

 	}

 EXPORT_C TBool TAlgStyle::operator==(const TAlgStyle& aAlgStyle) const

 	{

 	return (iFlags==aAlgStyle.iFlags) && 

 	       (iWidthFactor==aAlgStyle.iWidthFactor) &&

 	       (iHeightFactor==aAlgStyle.iHeightFactor) &&

 	       (iBaselineOffsetInPixels==aAlgStyle.iBaselineOffsetInPixels);

 	}

 /**

 @internalTechnology

 */

 TBool TAlgStyle::operator!=(const TAlgStyle& aAlgStyle) const

 	{

 	return !this->operator==(aAlgStyle);

 	}

 CBitmapFont::CBitmapFont(

 	RHeap*				aHeap,

 	const TFontSpec&	aFontSpecInTwips,

 	const TAlgStyle&	aAlgStyle,

 	CFontBitmap*		aFontBitmap):

 	iFontSpecInTwips(aFontSpecInTwips),

 	iAlgStyle(aAlgStyle),

 	iHeap(aHeap)

 	{

 	iFontBitmapOffset = (TInt) ((TUint)(aFontBitmap) - (TUint)(this));

 	}

 CBitmapFont::CBitmapFont(

 	RHeap*				aHeap,

 	const TFontSpec&	aFontSpecInTwips,

 	const TAlgStyle&	aAlgStyle,

 	COpenFont*			aOpenFont):

 	iFontSpecInTwips(aFontSpecInTwips),

 	iAlgStyle(aAlgStyle),

 	iHeap(aHeap)

 	{

     // Set iOpenFont to be the offset of aOpenFont from the address of CBitmapFont.

     // In order to be able to identify iOpenFont as an offset instead of a pointer,

     // bitwise or the offset with 1.  Pointers will always be word aligned (and therefore even).

     if (aOpenFont)

         {

         __ASSERT_DEBUG(!(reinterpret_cast<TInt>(aOpenFont) & 1), Panic(EFntPointerNotByteAligned));

         iOpenFont = reinterpret_cast<COpenFont*>((reinterpret_cast<TInt>(aOpenFont) - reinterpret_cast<TInt>(this)) | 1);

         }

     else

         {

         iOpenFont = NULL;

         }

 	}

 /** This member is private and not intended for use. */

 void CBitmapFont::ConstructL()

 	{

 	if (!IsOpenFont())

 		FontBitmap()->UseL();

 	}

 /** This member is private and not intended for use. */

 CBitmapFont::~CBitmapFont()

 	{	

 	if (!IsOpenFont() && iFontBitmapOffset)

 		FontBitmap()->Release();

 	else if (IsOpenFont())

 		delete OpenFont();

 	}	

 CBitmapFont* CBitmapFont::NewL(

 	RHeap*				aHeap,

 	const TFontSpec&	aFontSpecInTwips,

 	const TAlgStyle&	aAlgStyle,

 	CFontBitmap*		aFontBitmap)

 	{

 	// font is placed in shared heap

 	CBitmapFont* f = (CBitmapFont*) aHeap->AllocL(sizeof(CBitmapFont));

 	new(f) CBitmapFont(aHeap, aFontSpecInTwips, aAlgStyle, aFontBitmap);

 	CleanupStack::PushL(f);

 	f->ConstructL();

 	CleanupStack::Pop(f);

 	return f;

 	}

 CBitmapFont* CBitmapFont::NewL(

 	RHeap*				aHeap,

 	const TFontSpec&	aFontSpecInTwips,

 	const TAlgStyle&	aAlgStyle,

 	COpenFont*			aOpenFont)

 	{

 	// font is placed in shared heap

 	CBitmapFont* f = (CBitmapFont*) aHeap->AllocL(sizeof(CBitmapFont));

 	new(f) CBitmapFont(aHeap,aFontSpecInTwips,aAlgStyle,aOpenFont);

 	return f;

 	}

 /** Returns the font type identifier:KCBitmapFontUidVal.

 @return The font type identifier. */

 EXPORT_C TUid CBitmapFont::DoTypeUid() const

 	{

 	return TUid::Uid(KCBitmapFontUidVal);

 	}

 /** Returns a font identifier.

 If it uses an open font the UID returned has a value of zero. Otherwise it 

 has the UID value of the CFontBitmap it uses.

 @return A font identifier. */

 TUid CBitmapFont::Uid() const

 	{

 	if (IsOpenFont())

 		return TUid::Uid(0);	

 	else

 		return FontBitmap()->iUid;

 	}

 /** Returns the font height in pixels.

 For an open font this will be the design height (notional rather than exact).

 @return Font height in pixels.

 @see FontMaxHeight()

 */

 EXPORT_C TInt CBitmapFont::DoHeightInPixels() const

 	{

 	if (IsOpenFont())

 		return Height(OpenFont()->Metrics().Size());	

 	else

 		return Height(FontBitmap()->iCellHeightInPixels);

 	}

 /** Returns the font ascent in pixels.

 The ascent is usually the height of a Latin capital letter above the baseline.

 For an open font, the returned value is likely to be inaccurate.

 Don't rely on it to get exact metrics at the pixel level.

 @return Font ascent in pixels.

 @see FontCapitalAscent()

 @see FontMaxAscent()

 */

 EXPORT_C TInt CBitmapFont::DoAscentInPixels() const

 	{

 	if (IsOpenFont())

 		return Height(OpenFont()->Metrics().Ascent());	

 	else

 		return Height(FontBitmap()->iAscentInPixels);

 	}

 /** Returns the width, in pixels, of the given character.

 If all characters have the same width (i.e. the font is mono - an attribute 

 stored in iAlgStyle) then this is the maximum normal width, returned using 

 MaxNormalCharWidthInPixels().

 Note: For OpenType fonts this function returns the horizontal advance of

 the character, which may be different from the actual width.

 @param aChar A character.

 @return The character width in pixels. */

 EXPORT_C TInt CBitmapFont::DoCharWidthInPixels(TChar aChar) const

 	{

 	const TUint8* bytes;

 	if (iAlgStyle.IsMono())

 		return MaxNormalCharWidthInPixels();

 	else

 		return Width(CharacterMetrics(aChar,bytes).iMoveInPixels);

 	}

 /** Returns the width, in pixels, of the given text.

 @param aText Text string.

 @return Width of the text in pixels. */

 EXPORT_C TInt CBitmapFont::DoTextWidthInPixels(const TDesC &aText) const

 	{

 	TMeasureTextInput* dummy = NULL;

 	return DoTextWidthInPixels(aText, dummy);

 	}

 /** Returns the width, in pixels, of the given text.

 @param aText Text string.

 @return Width of the text in pixels. */

 TInt CBitmapFont::DoTextWidthInPixels(const TDesC &aText, const TMeasureTextInput* aParam) const

 	{

 	TMeasureTextOutput output;

 	TInt advance_width = MeasureText(aText,aParam,&output);

 	return Max(advance_width,output.iBounds.Width());

 	}

 /** Returns the baseline offset in pixels, as stored in iAlgStyle.

 @return The baseline offset in pixels. */

 EXPORT_C TInt CBitmapFont::DoBaselineOffsetInPixels() const

 	{

 	return iAlgStyle.iBaselineOffsetInPixels;

 	}

 /** Returns the number of whole characters of aText, starting from the beginning, 

 that fit into the given pixel width.

 @param aText A text string.

 @param aWidthInPixels A width in pixels.

 @return The number of whole characters of aText that fit into aWidthInPixels.

 */

 EXPORT_C TInt CBitmapFont::DoTextCount(const TDesC &aText,TInt aWidthInPixels) const

 	{

 	TInt count = 0;

 	const TInt length = aText.Length();

 	TInt width = 0;

 	// accumulate text width character by character, until target is reached or exceeded

 	TInt widthDiff = aWidthInPixels - width;

 	while ( (widthDiff > 0) && (length > count) )

 		{ 

 		width += TextWidthInPixels(aText.Mid(count,1));

 		widthDiff = aWidthInPixels - width;

 		if (widthDiff >= 0)

 			{ // width <= aWidthInPixels

 			++count;

 			}

 		}

 	return count;

 	}

 /** Returns the number of whole characters of aText, starting from the beginning, 

 that fit into the given pixel width, and gets the excess width.

 @param aText A text descriptor.

 @param aWidthInPixels A width in pixels.

 @param aExcessWidthInPixels On return, the width left over of aWidthInPixels 

 after the maximum possible whole number of characters of aText have been fit 

 into it.

 @return The number of whole characters of aText that fit into aWidthInPixels. */

 EXPORT_C TInt CBitmapFont::DoTextCount(const TDesC &aText,TInt aWidthInPixels,TInt &aExcessWidthInPixels) const

 	{

 	TInt count = TextCount(aText,aWidthInPixels);

 	aExcessWidthInPixels = aWidthInPixels - TextWidthInPixels(aText.Left(count));

 	return count;

 	}

 /** Returns the font's maximum character width in pixels.

 @return The maximum character width in pixels. */

 EXPORT_C TInt CBitmapFont::DoMaxCharWidthInPixels() const

 	{

 	if (IsOpenFont())

 		return Width(OpenFont()->Metrics().MaxWidth());	

 	else

 		return Width(FontBitmap()->iMaxCharWidthInPixels);

 	}

 /** Returns the font's normal maximum character width in pixels.

 Note that when a CFontBitmap is used this value is the same as the maximum 

 character width in pixels returned by MaxCharWidthInPixels(), but when a COpenFont 

 is used the value may be different.

 @return The normal maximum character width in pixels. */

 EXPORT_C TInt CBitmapFont::DoMaxNormalCharWidthInPixels() const

 	{

 	if (IsOpenFont())

 		return Width(OpenFont()->Metrics().MaxWidth());

 	else

 		return Width(FontBitmap()->iMaxNormalCharWidthInPixels);

 	}

 /** Returns the device-independent font specification for the font.

 Note that this is set when the bitmap font object is constructed.

 @return A font specification. */

 EXPORT_C TFontSpec CBitmapFont::DoFontSpecInTwips() const

 	{

 	return iFontSpecInTwips;

 	}

 /** Attempts to rasterize a character (aCode) into a data area (aGlyphData) in 

 shared memory.

 This works only for open fonts: where the bitmap font object is using a COpenFont.

 Bitmap fonts are deemed to be fully rasterized after they have been loaded 

 from file. 

 Returns ETrue if the character was successfully rasterized or was already 

 in the cache. This function can be called only by the server; rasterization 

 uses memory and other resources (e.g., file handles) owned by the server. 

 @param aSessionHandle A session handle for the open font system.

 @param aCode A character code.

 @param aGlyphData A data area in shared memory.

 @return ETrue if the character was successfully rasterized or was already in 

 the cache; otherwise EFalse. */

 EXPORT_C TBool CBitmapFont::Rasterize(TInt aSessionHandle, TInt aCode, TOpenFontGlyphData* aGlyphData) const

 	{

 	if (IsOpenFont())

 		return OpenFont()->Rasterize(aSessionHandle, aCode, aGlyphData);

 	else

 		return EFalse;

 	}

 /** Gets a pointer to a bitmap and the metrics for a specified character, but only 

 if a CFontBitmap is being used by the bitmap font object.

 This function does not work when a COpenFont is being used, but GetCharacterData() 

 can be used instead.

 If the specified character does not exist in the font then the bitmap pointer 

 and character metrics are gotten for a replacement character, KReplacementCharacter.

 @param aCode A character code.

 @param aBytes On return, a pointer to the bitmap for the specified character.

 @return Metrics for the specified character. */

 EXPORT_C TCharacterMetrics CBitmapFont::CharacterMetrics(TInt aCode,const TUint8*& aBytes) const

 	{

 	/*

 	This function does not work for Open Fonts because the character data need not be

 	shared between sessions and a session handle is needed; GetCharacterData should be used instead.

 	*/

 	if (IsOpenFont())

 		{

 		aBytes = NULL;

 		return TCharacterMetrics();

 		}

 	TBitmapFontCharacterMetrics bitmap_font_metrics = FontBitmap()->CharacterMetrics(aCode,aBytes);

 	// Substitute the replacement character if this character doesn't exist in the font.

 	if (aBytes == NULL)

 		bitmap_font_metrics = FontBitmap()->CharacterMetrics(KReplacementCharacter,aBytes);

 	TCharacterMetrics metrics;

 	metrics.iAscentInPixels = bitmap_font_metrics.iAscentInPixels;

 	metrics.iHeightInPixels = bitmap_font_metrics.iHeightInPixels;

 	metrics.iLeftAdjustInPixels = bitmap_font_metrics.iLeftAdjustInPixels;

 	metrics.iMoveInPixels = bitmap_font_metrics.iMoveInPixels;

 	metrics.iRightAdjustInPixels = bitmap_font_metrics.iRightAdjustInPixels;

 	if (iAlgStyle.IsMono())

 		{

 		TInt width = metrics.iMoveInPixels - metrics.iLeftAdjustInPixels - metrics.iRightAdjustInPixels;

 		metrics.iMoveInPixels = FontBitmap()->iMaxNormalCharWidthInPixels;

 		metrics.iLeftAdjustInPixels = (TInt16)((metrics.iMoveInPixels - width) / 2);

 		metrics.iRightAdjustInPixels = (TInt16)(metrics.iMoveInPixels - width - metrics.iLeftAdjustInPixels);

 		}

 	return metrics;	 // N.B. Not doubled for double height and double width.

 	}

 /** Gets a pointer to a bitmap and the metrics for a specified character.

 Note that this function calls CharacterMetrics() if a CFontBitmap is being 

 used by the bitmap font object, and maps the TCharacterMetrics values returned 

 by that function to aMetrics.

 If the function fails to get the bitmap and metric values (because the character 

 is in an open font and has not yet been rasterized) returns EFalse.

 @param aSessionHandle A session handle for the open font system.

 @param aCode A character code.

 @param aMetrics On return, metrics for the specified character.

 @param aBitmap On return, a pointer to the bitmap for the specified character.

 @return ETrue if successful, otherwise EFalse. */

 EXPORT_C TBool CBitmapFont::GetCharacterData(TInt aSessionHandle,TInt aCode,

 											 TOpenFontCharMetrics& aMetrics,const TUint8*& aBitmap) const

 	{

 	if (IsOpenFont())

 		{

 		const TOpenFontCharMetrics* nm;

 		if (OpenFont()->GetCharacterData(aSessionHandle,aCode,nm,aBitmap))

 			{

 			aMetrics = *nm;

 			return ETrue;

 			}

 		else

 			return EFalse;

 		}

 	else

 		{

 		TCharacterMetrics m = CharacterMetrics(aCode,aBitmap);

 		aMetrics = TOpenFontCharMetrics(m);

 		return ETrue;

 		}

 	}

 /** Gets the open font metrics. 

 These metrics distinguish between maximum character height and depth and typographic 

 ascent and descent, so that the clipping rectangle for text can be distinguished 

 from the distance to neighbouring baselines. 

 @param aMetrics Open font metrics. */

 EXPORT_C void CBitmapFont::GetFontMetrics(TOpenFontMetrics& aMetrics) const

 	{

 	if (IsOpenFont())

 		aMetrics = OpenFont()->Metrics();

 	else

 		{

 		new(&aMetrics) TOpenFontMetrics;

 		aMetrics.SetSize(CBitmapFont::DoHeightInPixels());

 		aMetrics.SetAscent(CBitmapFont::DoAscentInPixels());

 		aMetrics.SetDescent(aMetrics.Size() - aMetrics.Ascent());

 		aMetrics.SetMaxHeight(aMetrics.Ascent());

 		aMetrics.SetMaxDepth(aMetrics.Descent());

 		aMetrics.SetMaxWidth(CBitmapFont::DoMaxCharWidthInPixels());

 		}

 	}

 /** Gets the open font typeface attributes if possible. 

 At present no attempt is made to sythesize these attributes for bitmap fonts 

 (CFontBitmaps). 

 @param aAttrib On return, the open font typeface attributes.

 @return ETrue if successful; EFalse if not possible to get the open font typeface 

 attributes. */

 EXPORT_C TBool CBitmapFont::GetFaceAttrib(TOpenFontFaceAttrib& aAttrib) const

 	{

 	if (IsOpenFont())

 		{

 		const TOpenFontFaceAttrib* a = OpenFont()->FaceAttrib();

 		if (a)

 			{

 			aAttrib = *a;

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 /** Gets encoding if a bitmap font (a CFontBitmap) is used.

 @return Bitmap encoding value. */

 EXPORT_C TInt CBitmapFont::BitmapEncoding() const

 	{

 	if (IsOpenFont())

 		return 0;

 	else

 		return FontBitmap()->iBitmapEncoding;

 	}

 /** Gets whether the open or bitmap font has the specified character.

 @param aCode A character code.

 @return ETrue if the font has the specified character; otherwise EFalse. */

 EXPORT_C TBool CBitmapFont::HasCharacterL(TInt aCode) const

 	{

 	if (IsOpenFont())

 		return OpenFont()->HasCharacterL(aCode);

 	else

 		{

 		const TUint8* bytes;

 		FontBitmap()->CharacterMetrics(aCode,bytes);

 		return (bytes != NULL);

 		}

 	}

 /** Gets whether the specified character needs to be rasterised.

 False is returned if it is a bitmap font (a CFontBitmap) being used by the 

 bitmap font object (so no rasterization is required) or if is an open font 

 (a COpenFont) and the character has been rasterized.

 @param aSessionHandle A session handle for the open font system.

 @param aCode A character code.

 @return ETrue if the character needs to be rasterized; otherwise EFalse. */

 EXPORT_C TBool CBitmapFont::CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const

 	{

 	if (IsOpenFont())

 		return OpenFont()->CharacterNeedsToBeRasterized(aSessionHandle,aCode);

 	else

 		return FALSE;	// characters in bitmap fonts do not need to be rasterized	

 	}

 /** Turns text into glyph codes and positions.

 @param aText The Unicode text to shape plus context

 @return The output shape header from the per-font cache, or 0 on failure.

 @internalTechnology

 */

 EXPORT_C TShapeHeader* CBitmapFont::ShapeTextL(const TDesC16& aText,

 	TInt aSessionHandle, const TShapeMessageParameters& aParams)

 	{

 	TShapeHeader* shape = 0;

 	if(IsOpenFont())

 		{

 		// get the data in a CShaper::TInput for the shaper

 		CShaper::TInput input;

 		input.iText = &aText;

 		input.iStart = aParams.iStart;

 		input.iEnd = aParams.iEnd;

 		input.iScript= aParams.iScript;

 		input.iLanguage = aParams.iLanguage;

 		input.iMaximumAdvance = KMaxTInt;

 		input.iFlags = 0;

 		input.iSessionHandle = aSessionHandle;

 		input.iReserved1 = 0;

 		TFontShapeFunctionParameters params;

 		params.iEnd = input.iEnd;

 		params.iLanguage = input.iLanguage;

 		params.iScript = input.iScript;

 		params.iStart = input.iStart;

 		params.iText = input.iText;

 		COpenFont* openFont = OpenFont();

 		//if already exist just increase the reference count for that session

 		shape = openFont->GetShapedData(aSessionHandle,&params);

 		if (shape == NULL)

 			{

 			if (!openFont->HasShaper()

  				|| (openFont->HasShaper() && ( 

  				(TUint32)(openFont->GetShaper()->ExtendedInterface(KUidShaperGetScript)) != input.iScript

  				|| (TUint32)(openFont->GetShaper()->ExtendedInterface(KUidShaperGetLang)) != input.iLanguage)))

 				{ // Install the shaper

 				openFont->DeleteShaper();

 				InstallOpenFontShaper(openFont, input);

 				}

 			if (openFont->HasShaper())

 				{

 				TInt error = openFont->GetShaper()->ShapeText(shape, input, iHeap);

 				if (error != KErrNone)

 					User::Leave(error);

 				// Put this into the session cache

 				TShapeHeader* cached_header = openFont->InsertShapedDataIntoCache(aSessionHandle,&params, shape);

 				if (!cached_header)

 					User::LeaveNoMemory();

 				iHeap->Free(shape);

 				shape = cached_header;

 				}

 			}

 		}

 	return shape;

 	}

 void CBitmapFont::InstallOpenFontShaper(COpenFont* aOpenFont, CShaper::TInput& aShaperInput)

 	{

 	CShaper* shaper = NULL;

 	const CArrayPtrFlat<CShaperFactory>* shaperFactoryList = aOpenFont->File()->GetFontStore()->ShaperFactoryList();

 	TInt factoryCount = shaperFactoryList->Count();

 	for (TInt index = 0; index < factoryCount; index++)

 		{

 		TRAPD(err, shaper = (*shaperFactoryList)[index]->NewShaperL(this,

 				aShaperInput.iScript, aShaperInput.iLanguage,  iHeap));

 		if (err == KErrNone)

 			{

 			aOpenFont->SetShaper(shaper);

 			OstTrace0( TRACE_IMPORTANT, CBITMAPFONT_INSTALLOPENFONTSHAPER, "A shaper is installed" );

 			break;

 			}

 		}

 	}

 /** Frees the memory taken up as a result of shaping

 @internalTechnology */

 EXPORT_C void CBitmapFont::DeleteShape(TInt aSessionHandle,TShapeHeader* aHeader)

 	{

 	//safe to assume aHeader is never NULL?

 	if (IsOpenFont())

 		{

 		//we just need to decrease the reference count, no deletion here

 		//as the entry in cache can still be reused by other client

 		//only in the case where the memory is full, the freeing will

 		//delete any cache entry that is not referenced at all

 		TInt ret=OpenFont()->DecrementCachedRefCount(aSessionHandle,aHeader);

 		//panic in debug mode if trying to delete something that is not there.

 		if ((ret != KErrNone) && (ret != KErrNotFound))

 		    {

 		    OstTrace1( TRACE_FATAL, CBITMAPFONT_DELETESHAPE, "OpenFont()->DecrementCachedRefCount() return %d, Invariant", ret);

 		    __ASSERT_DEBUG(0, User::Invariant());

 		    }

 		}

 	}

 EXPORT_C void CBitmapFont::operator delete(TAny *aThis)

 	{

 	if (((CBitmapFont *)aThis)->iHeap)

 		((CBitmapFont *)aThis)->iHeap->Free(aThis);

 	}

 TInt CBitmapFont::Width(TInt aNum) const

 	{

 	TInt widthfactor=iAlgStyle.WidthFactor();

 	return ((widthfactor==1)? aNum: aNum*widthfactor);

 	}

 TInt CBitmapFont::Height(TInt aNum) const

 	{

 	TInt heightfactor=iAlgStyle.HeightFactor();

 	return ((heightfactor==1)? aNum: aNum*heightfactor);

 	}

 CFontBitmap* CBitmapFont::FontBitmap() const

 /** This member is private and not intended for use. */

 	{

 	if (IsOpenFont())

 	    {

 	    OstTrace0( TRACE_FATAL, CBITMAPFONT_FONTBITMAP, "Panic(EFntTypefaceHasNoFontBitmaps)" );

 	    __ASSERT_ALWAYS(0, Panic(EFntTypefaceHasNoFontBitmaps));

 	    }

     if(iFontBitmapOffset)

         return reinterpret_cast<CFontBitmap*>(reinterpret_cast<TInt>(this)+iFontBitmapOffset);

     else

         return NULL;

 	}

 /** Gets a font table.

 @param aTag: Input. The name of the font table.

 @param aTableContent: Output. To return the address of the table content.

 @param aLength: Output. To return the length (in bytes) of the table.

 @param aSessionHandle: Input. A handle to the session requesting this table.

 @return KErrNone on success, specific error code on failure.

 @internalTechnology

 */

 EXPORT_C TInt CBitmapFont::GetFontTable(TUint32 aTag, TAny *&aTableContent, 

         TInt &aLength, TInt aSessionHandle) 

     {

     COpenFont *fontPtr = NULL;

     if (IsOpenFont())

         fontPtr = OpenFont();

     else

         return KErrNotSupported;

     // try to find it in cache.

     CFontStore *fntStore = fontPtr->File()->GetFontStore();

     TUid fileUid = fontPtr->File()->Uid();

     TInt ret = fntStore->FindFontTableInCache(fileUid, aTag, aTableContent, aLength);

     if (KErrNone == ret)

         {

         ret = fntStore->IncFontTableRefCount(fileUid, aTag, aSessionHandle);

         return ret;

         }

     // font table not found in cache.

     ret = fontPtr->GetFontTable(aTag, aTableContent, aLength);

     if (KErrNone == ret)

         {

         ret = fntStore->CacheFontTable(fileUid, aTag, aTableContent, aLength);

         if (KErrNone == ret)

             {

             ret = fntStore->IncFontTableRefCount(fileUid, aTag, aSessionHandle);

             }

         else 

             {

             aTableContent = NULL;

             }

         }

     return ret;

     }

 /** Release a font table. Decrement its reference count. Remove from cache if 

  * reference decreases to zero.

 @param aTag: Input. The name of the font table to be released.

 @param aSessionHandle: Input. Handle to the session releasing this table.

 @return KErrNone on success, specific error code on failure.

 @internalTechnology

 */

 EXPORT_C void CBitmapFont::ReleaseFontTable(TUint32 aTag, 

         TInt aSessionHandle)

     {

     COpenFont *fontPtr = NULL;

     if (IsOpenFont())

         fontPtr = OpenFont();

     else

         return;

     CFontStore *fntStore = fontPtr->File()->GetFontStore();

     TUid fileUid = fontPtr->File()->Uid();

     fntStore->ReleaseFontTable(fileUid, aTag, aSessionHandle);

     }

 /** Release a number of glyph outlines. Decrement their reference count.

  * Remove it from cache if reference count decreases to zero.

 @param aCount: Input. Number of outlines to be released.

 @param aCodes: Input. An array of codes. Its interpretation depends on the parameter

     'aIsGlyphId' (see below).

 @param aIsGlyphId: Input. When aIsGlyphId==ETrue, 'aCodes' is an array of glyph ID's.

     When aIsGlyphId==EFalse, 'aCodes' is an array of Unicode values.

 @param aHinted: Input. To indicate if the outlines are hinted or unhinted.

 @param aSessionHandle: Input. Handle to the session releasing the outlines.

 @return KErrNone on success, specific error code on failure.

 @internalTechnology

 */

 EXPORT_C void CBitmapFont::ReleaseGlyphOutlines(TInt aCount, const TUint *aCodes, 

         TBool aHinted, TInt aSessionHandle)

     {

     COpenFont *fontPtr = NULL;

         if (IsOpenFont())

             fontPtr = OpenFont();

         else

             return;

     CFontStore *fontStore = fontPtr->File()->GetFontStore();

     for (TInt i = 0; i < aCount; ++i)

         {

         if (aHinted)

             {

             THintedOutlineId outlineId(fontPtr, aCodes[i]);

             fontStore->ReleaseHintedOutline(outlineId, aSessionHandle);

             }

         else

             {

             TInt faceId = fontPtr->FaceIndex();

             TUnhintedOutlineId outlineId(fontPtr->File()->Uid(), faceId, aCodes[i]);

             fontStore->ReleaseUnhintedOutline(outlineId, aSessionHandle);

             }

         }

     }

 /** Gets a font table.

 @param aCode: Input. An glyph code. Its interpretation depends on the parameter

     'aIsGlyphId' (see below).

 @param aIsGlyphId: Input. When aIsGlyphId==ETrue, 'aCode' is a glyph ID.

     When aIsGlyphId==EFalse, 'aCode' is a Unicode values.

 @param aHinted: Input. To indicate if hinted or unhinted outline is needed.

 @param aOutline: Output. A 'void*' pointer, pointing to the outline in memory.

 @param aLength: Output. A TInt, recording the lenght (in bytes) of the outline.

 @param aSessionHandle: Input. Handle to the session requesting this outline.

 @return KErrNone on success, specific error code on failure.

 @internalTechnology

 */

 EXPORT_C TInt CBitmapFont::GetGlyphOutline(TUint aCode, 

         TBool aHinted, TAny *&aOutline, TInt &aLength, TInt aSessionHandle)

     {

     COpenFont *fontPtr = NULL;

         if (IsOpenFont())

             fontPtr = OpenFont();

         else

             return KErrNotSupported;

     CFontStore *fontStore = fontPtr->File()->GetFontStore();

     TAny *outlineData = NULL; 

     TInt len = KErrGeneral;

     TInt ret = KErrNone;

     if (!aHinted)

         {

         TInt faceId = fontPtr->FaceIndex();

         TUnhintedOutlineId outlineId(fontPtr->File()->Uid(), faceId, aCode);

         ret = fontStore->FindUnhintedOutlineInCache(outlineId, outlineData, len);

         if (KErrNotFound == ret)

             {

             TAny* tmpOutline = 0; 

             TInt tmpLen = 0;

             ret = fontPtr->GetGlyphOutline(aCode, aHinted, tmpOutline, tmpLen);

             if (KErrNone == ret)

                 {

                 fontStore->CacheUnhintedOutline(outlineId,

                         tmpOutline, (TInt)tmpLen, outlineData, len);

                 }

             User::Free(tmpOutline);

             }

         if (KErrNone == ret)

             {

             fontStore->IncreaseUnhintedOutlineRefCount(outlineId, aSessionHandle);

             }

         }

     else 

         {

         THintedOutlineId outlineId(fontPtr, aCode);

         ret = fontStore->FindHintedOutlineInCache(outlineId, outlineData, len);

         if (KErrNotFound == ret)

             {

             TAny* tmpOutline = 0; 

             TInt tmpLen = 0;

             ret = fontPtr->GetGlyphOutline(aCode, aHinted, tmpOutline, tmpLen);

             if (KErrNone == ret)

                 {

                 fontStore->CacheHintedOutline(outlineId,

                         tmpOutline, (TInt)tmpLen, outlineData, len);

                 }

             User::Free(tmpOutline);

             }

         if (KErrNone == ret)

             {

             fontStore->IncreaseHintedOutlineRefCount(outlineId, aSessionHandle);

             }

         }

     aOutline = outlineData;

     aLength = len;    

     return KErrNone;

     }

 EXPORT_C TUint32 CBitmapFont::UniqueFontId()

 	{

 	return iUniqueFontId;

 	}

 void CBitmapFont::SetUniqueFontId(TUint32 aUniqueFontId)

 	{

 	iUniqueFontId = aUniqueFontId;	

 	}

 /** API extension system that enables the caller to access a particular API

 extension function. As an overload of this function in a derived class

 it calls its immediate parent implementation for any extension function Uid

 that it does not recognize and handle.

 @param aInterfaceId UID of the required extension function

 @param aParam Pointer to an arbitrary parameter block that can be used to

 provide and/or return information to/from the particular extension function,

 defaults to NULL.

 @return Integer return value from extension function

 @internalTechnology

 @released

 */

 EXPORT_C TInt CBitmapFont::DoExtendedFunction(TUid aFunctionId, TAny* aParam) const

 	{

 	if (KFontCapitalAscent == aFunctionId)

 		{

 		return Height(IsOpenFont() ? OpenFont()->FontCapitalAscent() : FontBitmap()->FontCapitalAscent());

 		}

 	else if (KFontMaxAscent == aFunctionId)

 		{

 		return Height(IsOpenFont() ? OpenFont()->FontMaxAscent() : FontBitmap()->FontMaxAscent());

 		}

 	else if (KFontStandardDescent == aFunctionId)

 		{

 		return Height(IsOpenFont() ? OpenFont()->FontStandardDescent() : FontBitmap()->FontStandardDescent());

 		}

 	else if (KFontMaxDescent == aFunctionId)

 		{

 		return Height(IsOpenFont() ? OpenFont()->FontMaxDescent() : FontBitmap()->FontMaxDescent());

 		}

 	else if (KFontLineGap == aFunctionId)

 		{

 		return Height(IsOpenFont() ? OpenFont()->FontLineGap() : FontBitmap()->FontLineGap());

 		}

 	return CFont::DoExtendedFunction(aFunctionId, aParam);

 	}

 CFontTableCacheItem::CFontTableCacheItem(TUid &aFileUid, const TUint32 aTag, 

         TInt aOffset, TInt aLength): iFileUid(aFileUid), iTag(aTag),

         iOffset(aOffset), iLength(aLength)

     {

     // a null constructor

     }

 CFontTableCacheItem::~CFontTableCacheItem()

     {

     iUsers.ResetAndDestroy();

     iUsers.Close();

     }

 TBool CFontTableCacheItem::HasOutstandingRefCount()

     {

     TInt count = iUsers.Count();

     for (TInt j = 0; j < count; ++j)

         {

         if (iUsers[j]->iRefCount > 0) 

             {

             return ETrue;

             }

         }

     return EFalse;

     }

 TInt CFontTableCacheItem::FindUser(TInt aSessionHandle, TInt *id) 

     {

     TInt len = iUsers.Count();

     for (TInt i = 0; i < len; ++i)

         {

         if (aSessionHandle == iUsers[i]->iSessionHandle)

             {

             *id = i;

             return KErrNone;

             }

         }

     return KErrNotFound;

     }

 TInt CFontTableCacheItem::DecRefCount(TInt aSessionHandle)

     {

     TInt id = 0; 

     TInt ret = FindUser(aSessionHandle, &id);

     if (KErrNone == ret)

         {

         iUsers[id]->iRefCount--;

         if (0 == iUsers[id]->iRefCount) 

             {

             delete iUsers[id];

             iUsers.Remove(id);

             }

         return iUsers.Count();

         }

     return KErrNotFound;

     }

 TInt CFontTableCacheItem::IncRefCount(TInt aSessionHandle)

     {

     TInt id = 0; 

     TInt ret = FindUser(aSessionHandle, &id);

     if (KErrNone == ret)

         {

         iUsers[id]->iRefCount++;

         }

     else

         {

         TCacheUserInfo *newUser = new TCacheUserInfo(aSessionHandle, 1);

         if (NULL != newUser)

             {

             TRAP(ret, iUsers.AppendL(newUser));

             }

         else 

             {

             ret = KErrNoMemory;

             }

         //coverity[leaked_storage]

         // The 'newUser' is kept in iUsers. It will be deleted in DecRefCount(). 

         }

     return ret;

     }

 TInt CFontTableCache::Append(TUid aFileUid, TUint32 aTag, 

         TAny *&aContent, TInt aLength) 

     {

     TInt ret = 0;

     if ((TUint32)iCacheMemMon.GetMemUsage() >= KFontTable_GlyphOutline_CacheMaxMem)

         {

         RDebug::Printf("Table/Glyph cache full. Unable to add new item.");

         return KErrNoMemory;

         }

     // make a copy of the table content on the shared heap.

     TAny *sharedCopy = iHeap->Alloc(aLength);

     if (NULL == sharedCopy) 

         {

         return KErrNoMemory;

         }

     Mem::Copy(sharedCopy, aContent, aLength);

     CFontTableCacheItem *newItem = NULL;

     TInt offset = PointerToOffset(sharedCopy, iHeap->Base());

     TRAP(ret, newItem = new(ELeave) CFontTableCacheItem(aFileUid, aTag, offset, aLength));

     if (KErrNone != ret)

         {

         iHeap->Free(sharedCopy);

         return ret;

         }

     TRAP(ret, iCacheItems.AppendL(newItem));

     if (KErrNone == ret)

         {

         // do not free 'aContent', because the mem is managed by

         // rasterizer cache.

         aContent = sharedCopy;

         iCacheMemMon.Inc(aLength);

         }

     else 

         {

         iHeap->Free(sharedCopy);

         }

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     return ret;

     }

 TInt CFontTableCache::Find(TUid aFileUid, TUint32 aTag, TAny *&aContent, 

         TInt &aLength, TInt *id)

     {

     *id = KErrNotFound;

     TInt len = iCacheItems.Count();

     TInt ret = KErrNotFound;

     for (TInt i = 0; i < len; ++i)

         {

         CFontTableCacheItem *item = iCacheItems[i]; 

         if (item->iFileUid == aFileUid && item->iTag == aTag) 

             {

             aContent = OffsetToPointer(item->iOffset, iHeap->Base());

             aLength = item->iLength;

             *id = i;

             ret = KErrNone;

             break;

             }

         }

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     return ret;

     }

 CFontTableCache::CFontTableCache(RHeap *aHeap, TFontTableGlyphOutlineCacheMemMonitor &aMon): 

     iCacheMemMon(aMon), iHeap(aHeap) 

     {

     // null constructor

     }

 CFontTableCache::~CFontTableCache()

     {

     for (TInt i = 0; i < iCacheItems.Count(); ++i)

         {

         iHeap->Free(OffsetToPointer(iCacheItems[i]->iOffset, iHeap->Base()));

         }

     iCacheItems.ResetAndDestroy();

     iCacheItems.Close();

     }

 TInt CFontTableCache::IncRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle)

     {

     TAny *outline = NULL;

     TInt len = 0;

     TInt id = 0;

     TInt ret = Find(aFileUid, aTag, outline, len, &id);

     if (KErrNone == ret)

         {

         ret = iCacheItems[id]->IncRefCount(aSessionHandle);

         }

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     return ret;

     }

 TInt CFontTableCache::DecRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle)

     {

     TAny *outline = NULL;

     TInt len = 0;

     TInt id = 0;

     TInt ret = Find(aFileUid, aTag, outline, len, &id);

     if (KErrNone == ret) 

         {

         TInt numUsers = iCacheItems[id]->DecRefCount(aSessionHandle);

         if (0 == numUsers) 

             {

             // There is no outstanding reference to the cache item.

             iHeap->Free(outline);

             iCacheMemMon.Dec(len);

             delete (iCacheItems[id]);

             iCacheItems.Remove(id);

             }

         }

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     return ret;

     }

 TBool CFontTableCache::HasOutstandingRefCount() 

     {

     TInt len = iCacheItems.Count();

     for (TInt i = 0; i < len; ++i)

         {

         if (iCacheItems[i]->HasOutstandingRefCount())

             {

             return ETrue;

             }

         }

     return EFalse;

     }

 TBool CFontTableCache::HasOutstandingRefCountWithUid(TUid aFileUid)

     {

     TInt len = iCacheItems.Count();

     for (TInt i = 0; i < len; ++i)

         {

         if (iCacheItems[i]->iFileUid == aFileUid) 

             {

             if (iCacheItems[i]->HasOutstandingRefCount())

                 {

                 return ETrue;

                 }

             }

         }

     return EFalse;

     }

 void CFontTableCache::CleanupCacheOnOpenFontFileRemoval(COpenFontFile *)

     {

     // In CFontStore::RemoveFile(), a font file is not allowed to be removed if

     // there are outstanding ref counts on any table in it. If that check passed 

     // and this function is called, there shall be no cache item for that file.

     // Currently a cache item having a refcount of 0 is removed immediately.

     // If this strategy is changed in the future, we may need to do some

     // cleanup here.

     }

 void CFontTableCache::CleanupCacheOnFbsSessionTermination(TInt aSessionHandle)

     {

     TInt len = iCacheItems.Count();

     for (TInt i = 0; i < len; ++i)

         {

         TInt id = -1;

         if (KErrNone == iCacheItems[i]->FindUser(aSessionHandle, &id))

             {

             iCacheItems[i]->iUsers.Remove(id);

             if (iCacheItems[i]->iUsers.Count() == 0)

                 {

                 iHeap->Free(OffsetToPointer(iCacheItems[i]->iOffset, iHeap->Base()));

                 iCacheMemMon.Dec(iCacheItems[i]->iLength);

                 delete iCacheItems[i];

                 iCacheItems.Remove(i);

                 }

             }

         }

     }

 #ifdef _DEBUG

 TInt CFontTableCache::GetCacheState(const char *func) 

     {

     RDebug::Printf("%s called from %s: ", __func__, func);

     TBuf<256> buf;

     int len = iCacheItems.Count();

     int numTables = 0, numSessions = 0, totalRef = 0;

     buf.Append(_L("Table cache: "));

     for (int i = 0; i < len; ++i)

         {

         ++numTables;

         TInt abc = iCacheItems[i]->iUsers.Count();

         numSessions += abc;

         for (int j = 0; j < abc; ++j)

             {

             totalRef += iCacheItems[i]->iUsers[j]->iRefCount;

             }

         }

     if (0 == iCacheItems.Count())

         {

         buf.Append(_L("cache empty. "));

         }

     else 

         {

         buf.AppendFormat(_L("%d tables referenced by %d sessions, total ref count %d"),

                 numTables, numSessions, totalRef);

         }

     RDebug::RawPrint(buf);

     return 0;

     }

 #endif

 TInt COutlineCacheItem::FindUser(TInt aSessionHandle, TInt *id) 

     {

     TInt len = iUsers.Count();

     for (TInt i = 0; i < len; ++i)

         {

         if (aSessionHandle == iUsers[i]->iSessionHandle)

             {

             *id = i;

             return KErrNone;

             }

         }

     return KErrNotFound;

     }

 COutlineCacheItem::~COutlineCacheItem() 

     { 

     iUsers.ResetAndDestroy(); 

     }

 COutlineCacheItem::COutlineCacheItem(TInt aOffset, TInt aLength):

     iOffset(aOffset), iLength(aLength)

     {

     // a null constructor.

     }

 TInt COutlineCacheItem::DecRefCount(TInt aSessionHandle)

     {

     TInt id = 0; 

     TInt ret = FindUser(aSessionHandle, &id);

     if (KErrNone == ret)

         {

         iUsers[id]->iRefCount--;

         if (0 == iUsers[id]->iRefCount) 

             {

             delete iUsers[id];

             iUsers.Remove(id);

             }

         return iUsers.Count();

         }

     return KErrNotFound;

     }

 TInt COutlineCacheItem::IncRefCount(TInt aSessionHandle)

     {

     TInt id = 0; 

     TInt ret = FindUser(aSessionHandle, &id);

     if (KErrNone == ret)

         {

         iUsers[id]->iRefCount++;

         }

     else

         {

         TCacheUserInfo *newUser = new TCacheUserInfo(aSessionHandle, 1);

         if (NULL != newUser)

             {

             TRAP(ret, iUsers.AppendL(newUser));

             }

         else 

             {

             ret = KErrNoMemory;

             }

         //coverity[leaked_storage]

         // The 'newUser' is kept in iUsers. It will be deleted in DecRefCount().

         }

     return ret;

     }

 #ifdef _DEBUG

 TInt CUnhintedOutlineCache::GetCacheState(const char *func)

     {

     RDebug::Printf("%s called from %s: ", __func__, func);

     int numSessions = 0, totalRef = 0;

     THashMapIter<TUnhintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         COutlineCacheItem **data = it.CurrentValue();

         int len = (*data)->iUsers.Count();

         numSessions += len;

         for (int j = 0; j < len; ++j)

             {

             totalRef += (*data)->iUsers[j]->iRefCount;

             }

         it.NextValue();

         }

     TBuf<256> buf;

     buf.Append(_L("Unhinted outline cache: "));

     TInt numItems = iItemIdMap.Count();

     if (0 == numItems)

         {

         buf.Append(_L("empty. "));

         }

     else 

         {

         buf.AppendFormat(_L("%d glyphs, %d sessions, total refcount %d"),

                 numItems, numSessions, totalRef);

         }

     RDebug::RawPrint(buf);

     return 0;

     }

 #endif

 CUnhintedOutlineCache::CUnhintedOutlineCache(RHeap *aHeap, TFontTableGlyphOutlineCacheMemMonitor &aMon):

     iCacheMemMon(aMon), iHeap(aHeap), 

     iItemIdMap(THashFunction32<TUnhintedOutlineId>(CUnhintedOutlineCache::IdHash),

         TIdentityRelation<TUnhintedOutlineId>(CUnhintedOutlineCache::IdIdentity))

     { 

     }

 CUnhintedOutlineCache::~CUnhintedOutlineCache()

     {

     THashMapIter<TUnhintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         const TUnhintedOutlineId *outlineId = it.CurrentKey();

         COutlineCacheItem **data = it.CurrentValue();

         // loop body here!

         iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

         delete (*data);

         iItemIdMap.Remove(*outlineId);

         // end loop body

         it.NextValue();

         }

     return;

     }

 TInt CUnhintedOutlineCache::CleanupCacheOnOpenFontFileRemoval(COpenFontFile *aFontFile)

     {

     TUid fileUid = aFontFile->Uid();

     THashMapIter<TUnhintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         const TUnhintedOutlineId *outlineId = it.CurrentKey();

         COutlineCacheItem **data = it.CurrentValue();

         // loop body here!

         if (outlineId->iFileUid == fileUid)

             {

             iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

             iCacheMemMon.Dec((*data)->iLength);

             delete (*data);

             iItemIdMap.Remove(*outlineId);

             }

         // end loop body

         it.NextValue();

         }

     return KErrNone;

     }

 TInt CUnhintedOutlineCache::CleanupCacheOnFbsSessionTermination(TInt aSessionHandle)

     {

     THashMapIter<TUnhintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         const TUnhintedOutlineId *outlineId = it.CurrentKey();

         COutlineCacheItem **data = it.CurrentValue();

         // loop body here!

         TInt id = 0;

         TInt ret = (*data)->FindUser(aSessionHandle, &id);

         if (KErrNone == ret)

             {

             delete (*data)->iUsers[id];

             (*data)->iUsers.Remove(id);

             if (0 == (*data)->iUsers.Count())

                 {

                 iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

                 iCacheMemMon.Dec((*data)->iLength);

                 delete (*data);

                 iItemIdMap.Remove(*outlineId);

                 }

             }

         // end loop body

         it.NextValue();

         }

     return KErrNone;

     }

 TInt CUnhintedOutlineCache::CacheUnhintedOutline(const TUnhintedOutlineId &aOutlineId, 

         TAny* const aData, const TInt aLength, TAny *&aOutline, TInt &aLen)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     if ((TUint32)iCacheMemMon.GetMemUsage() >= KFontTable_GlyphOutline_CacheMaxMem)

         {

         RDebug::Printf("Table/Glyph cache full. Unable to add new item.");

         return KErrNoMemory;

         }

     aLen = KErrGeneral;

     TInt ret1= KErrNone;

     // make a copy of the outline data on the shared heap.

     TAny *sharedCopy = iHeap->Alloc(aLength);

     if (NULL == sharedCopy) 

         {

         return KErrNoMemory;

         }

     Mem::Copy(sharedCopy, aData, aLength);

     COutlineCacheItem *newItem = NULL;

     TInt offset = PointerToOffset(sharedCopy, iHeap->Base());

     TRAP(ret1, newItem = new(ELeave) COutlineCacheItem(offset, aLength));

     if (KErrNone != ret1)

         {

         iHeap->Free(sharedCopy);

         sharedCopy = NULL;

         }

     else 

         {

         TRAP(ret1, iItemIdMap.InsertL(aOutlineId, newItem));

         if (KErrNone != ret1)

             {

             delete newItem;

             iHeap->Free(sharedCopy);

             sharedCopy = NULL;

             }

         else

             {

             iCacheMemMon.Inc(aLength);

             aLen = aLength;

             }

         }

     aOutline = sharedCopy;

     return ret1;  

     }

 TInt CUnhintedOutlineCache::IncRefCount(const TUnhintedOutlineId &aOutlineId,

         TInt aSessionHandle)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     COutlineCacheItem **ret = iItemIdMap.Find(aOutlineId);

     if (NULL != ret)

         {

         (*ret)->IncRefCount(aSessionHandle);

         }

     return (NULL==ret?KErrNotFound:KErrNone);

     }

 TInt CUnhintedOutlineCache::DecRefCount(const TUnhintedOutlineId &aOutlineId,

         TInt aSessionHandle)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     COutlineCacheItem **ret = iItemIdMap.Find(aOutlineId); 

     if (NULL != ret) 

         {

         TInt numUsers = (*ret)->DecRefCount(aSessionHandle);

         if (0 == numUsers) 

             {

             // There is no outstanding reference to the cache item.

             iHeap->Free(OffsetToPointer((*ret)->iOffset, iHeap->Base()));

             iCacheMemMon.Dec((*ret)->iLength);

             delete (*ret);

             iItemIdMap.Remove(aOutlineId);

             }

         }

     return (NULL==ret?KErrNotFound:KErrNone);

     }

 TInt CUnhintedOutlineCache::Find(const TUnhintedOutlineId &aOutlineId, TAny *&aData, 

         TInt &aLength)

     {

     COutlineCacheItem **ret = iItemIdMap.Find(aOutlineId);

     TInt ret2 = KErrNone;

     if (NULL != ret)

         {

         aData = OffsetToPointer((*ret)->iOffset, iHeap->Base());

         aLength = (*ret)->iLength;

         }

     else

         {

         ret2 = KErrNotFound;

         }

     return ret2;

     }

 TUint32 CUnhintedOutlineCache::IdHash(const TUnhintedOutlineId &outlineId)

     {

     // The hash value: 

     // bits 0-15: glyph id; 

     // bits 16-23: lower 8 bit of font file uid

     // bits 24-27: lower 4 bit of the face index

     // bit 28: 'isGlyphId'

     TUint32 ret = 0;

     ret |= (outlineId.iId & KOutlineGlyphIdHashMask);

     ret |= (KOutlineFileUidHashMask & (outlineId.iFileUid.iUid << 16));

     ret |= (KOutlineFaceIndexHashMask & (outlineId.iFaceIndex << 24));

     ret = (ret % 701);

     return ret;

     }

 TBool CUnhintedOutlineCache::IdIdentity(const TUnhintedOutlineId &id1, const TUnhintedOutlineId &id2)

     {

     return id1.iId == id2.iId && id1.iFaceIndex == id2.iFaceIndex &&

             id1.iFileUid == id2.iFileUid;

     }

 // hinted outline cache

 #ifdef _DEBUG

 TInt CHintedOutlineCache::GetCacheState(const char *func)

     {

     RDebug::Printf("%s called from %s: ", __func__, func);

     int numSessions = 0, totalRef = 0;

     THashMapIter<THintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         COutlineCacheItem **data = it.CurrentValue();

         int len = (*data)->iUsers.Count();

         numSessions += len;

         for (int j = 0; j < len; ++j)

             {

             totalRef += (*data)->iUsers[j]->iRefCount;

             }

         it.NextValue();

         }

     TBuf<256> buf;

     buf.Append(_L("Hinted outline cache: "));

     TInt numItems = iItemIdMap.Count();

     if (0 == numItems)

         {

         buf.Append(_L("empty. "));

         }

     else 

         {

         buf.AppendFormat(_L("%d glyphs, %d sessions, total refcount %d"),

                 numItems, numSessions, totalRef);

         }

     RDebug::RawPrint(buf);

     return 0;

     }

 #endif

 TInt CHintedOutlineCache::CleanupCacheOnOpenFontRemoval(COpenFont *aFont)

     {

     THashMapIter<THintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         const THintedOutlineId *outlineId = it.CurrentKey();

         COutlineCacheItem **data = it.CurrentValue();

         // loop body here!

         if (outlineId->iFont == aFont)

             {

             iCacheMemMon.Dec((*data)->iLength);

             iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

             delete (*data);

             iItemIdMap.Remove(*outlineId);

             }

         // end loop body

         it.NextValue();

         }

     return KErrNone;

     }

 TInt CHintedOutlineCache::CleanupCacheOnFbsSessionTermination(TInt aSessionHandle)

     {

     THashMapIter<THintedOutlineId, COutlineCacheItem*> it(iItemIdMap);

     it.NextValue();

     while (it.CurrentValue())

         {

         const THintedOutlineId *outlineId = it.CurrentKey();

         COutlineCacheItem **data = it.CurrentValue();

         // loop body here!

         TInt id = 0; 

         TInt ret = (*data)->FindUser(aSessionHandle, &id);

         if (KErrNone == ret)

             {

             delete (*data)->iUsers[id];

             (*data)->iUsers.Remove(id);

             if (0 == (*data)->iUsers.Count())

                 {

                 iCacheMemMon.Dec((*data)->iLength);

                 iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

                 delete (*data);

                 iItemIdMap.Remove(*outlineId);

                 }

             }

         // end loop body

         it.NextValue();

         }

     return KErrNone;

     }

 CHintedOutlineCache::CHintedOutlineCache(RHeap *aHeap, TFontTableGlyphOutlineCacheMemMonitor &aMon):

     iCacheMemMon(aMon), iHeap(aHeap), 

     iItemIdMap(THashFunction32<THintedOutlineId>(CHintedOutlineCache::IdHash),

         TIdentityRelation<THintedOutlineId>(CHintedOutlineCache::IdIdentity)) 

     { 

     // a null constructor

     }

 TInt CHintedOutlineCache::CacheHintedOutline(const THintedOutlineId &aOutlineId,

         TAny* aData, TInt aLength, TAny *&aOutline, TInt &aLen)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     if ((TUint32)iCacheMemMon.GetMemUsage() >= KFontTable_GlyphOutline_CacheMaxMem)

         {

         RDebug::Printf("Table/Glyph cache full. Unable to add new item.");

         return KErrNoMemory;

         }

     aLen = KErrGeneral;

     TInt ret = KErrNone;

     // make a copy of the outline data on the shared heap.

     TAny *sharedCopy = iHeap->Alloc(aLength);

     if (NULL == sharedCopy) 

         {

         return KErrNoMemory;

         }

     Mem::Copy(sharedCopy, aData, aLength);

     COutlineCacheItem *newItem = NULL;

     TInt offset = PointerToOffset(sharedCopy, iHeap->Base());

     TRAP(ret, newItem = new(ELeave) COutlineCacheItem(offset, aLength));

     if (KErrNone != ret)

         {

         iHeap->Free(sharedCopy);

         sharedCopy = NULL;

         }

     else 

         {

         TRAP(ret, iItemIdMap.InsertL(aOutlineId, newItem));

         if (KErrNone != ret)

             {

             delete newItem;

             iHeap->Free(sharedCopy);

             sharedCopy = NULL;

             }

         else

             {

             iCacheMemMon.Inc(aLength);

             aLen = aLength;

             }

         }

     aOutline = sharedCopy;

     return ret;

     }

 TInt CHintedOutlineCache::IncRefCount(const THintedOutlineId &aOutlineId, 

         TInt aSessionHandle)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     COutlineCacheItem **data = iItemIdMap.Find(aOutlineId);

     if (NULL != data)

         {

         (*data)->IncRefCount(aSessionHandle);

         }

     return (NULL==data?KErrNotFound:KErrNone);

     }

 TInt CHintedOutlineCache::DecRefCount(const THintedOutlineId &aOutlineId,

         TInt aSessionHandle)

     {

 #ifdef _DEBUG

     GetCacheState(__func__);

 #endif

     COutlineCacheItem **data = iItemIdMap.Find(aOutlineId);

     if (NULL != data) 

         {

         TInt numUsers = (*data)->DecRefCount(aSessionHandle);

         if (0 == numUsers) 

             {

             // There is no outstanding reference to the cache item.

             iCacheMemMon.Dec((*data)->iLength);

             iHeap->Free(OffsetToPointer((*data)->iOffset, iHeap->Base()));

             delete (*data);

             iItemIdMap.Remove(aOutlineId);

             }

         }

     return (NULL==data?KErrNotFound:KErrNone);

     }

 TInt CHintedOutlineCache::Find(const THintedOutlineId &aOutlineId, 

         TAny *&aData, TInt &aLength)

     {

     COutlineCacheItem **ret = iItemIdMap.Find(aOutlineId);

     TInt ret2 = KErrNone;

     if (NULL != ret)

         {

         aData = OffsetToPointer((*ret)->iOffset, iHeap->Base());

         aLength = (*ret)->iLength;

         }

     else

         {

         ret2 = KErrNotFound;

         }

     return ret2;

     }

 TUint32 CHintedOutlineCache::IdHash(const THintedOutlineId &outlineId)

     {

     // The hash value:

     // bits 0-15: the outline id

     // bits 16-27: the lower 12 bits of the font pointer

     // bit 28: 'isGlyphId'

     TUint32 ret = 0;

     ret |= (KOutlineGlyphIdHashMask & outlineId.iId);

     ret |= (KOutlineFontPtrHashMask & (((TUint32)outlineId.iFont) << 16));

     ret = ret % 701;

     return ret;

     }

 TBool CHintedOutlineCache::IdIdentity(const THintedOutlineId &id1, const THintedOutlineId &id2)

     {

     return id1.iId == id2.iId && id1.iFont == id2.iFont;

     }

 // hinted cache

 CFontStore::CFontStore(RHeap* aHeap):

 	iKPixelWidthInTwips(KDefaultPixelWidthInTwips),

 	iKPixelHeightInTwips(KDefaultPixelHeightInTwips),

 	iFs(),

 	iHeap(aHeap),

 	iFontStoreFileList(KDefaultArrayGranularity),			// list of EPOC Bitmap font files loaded

 	iTypefaceList(KDefaultArrayGranularity),

 	iFontBitmapList(KDefaultArrayGranularity),

 	iTypefaceFontBitmapList(KDefaultArrayGranularity),

 	iOpenFontFileList(KDefaultArrayGranularity),			// list of 'Open Font' files loaded

 	iOpenFontRasterizerList(KDefaultArrayGranularity),		// open rasterizers, in load order

 	iOpenFontUid(1),

 	iDefaultBitmapType(EMonochromeGlyphBitmap),

 	iShaperFactoryList(KDefaultArrayGranularity),

 	iOpenFontShaperCacheMemUsage(0),

 	iNumberOfShaperCaches(0),

 	iOpenFontTypefaceSupportList(KDefaultArrayGranularity),	// list of Open Font typefaces available

 	iUniqueFontIdCount(0)									// used to give every font a unique id

 	{

 	}

 void CFontStore::ConstructL()

 	{

 	// Cache is placed in the shared heap

 	iOpenFontSessionCacheList = (COpenFontSessionCacheList*)iHeap->AllocL(sizeof(COpenFontSessionCacheList));

 	new(iOpenFontSessionCacheList) COpenFontSessionCacheList;

 	CTypefaceStore::ConstructL();

 	User::LeaveIfError(iFs.Connect());

 	TMachineInfoV1Buf machineInfoBuffer;

 	User::LeaveIfError(UserHal::MachineInfo(machineInfoBuffer));

 	const TSize twipSize = machineInfoBuffer().iPhysicalScreenSize;

 	const TSize pixelSize = machineInfoBuffer().iDisplaySizeInPixels;

 	if (twipSize.iWidth > 0 && pixelSize.iWidth > 0)

 		iKPixelWidthInTwips = twipSize.iWidth * 1000 / pixelSize.iWidth;

 	if (twipSize.iHeight > 0 && pixelSize.iHeight > 0)

 		iKPixelHeightInTwips = twipSize.iHeight * 1000 / pixelSize.iHeight;

 	iCacheMemMon = new(ELeave) TFontTableGlyphOutlineCacheMemMonitor;

 	iUnhintedOutlineCache = new(ELeave) CUnhintedOutlineCache(iHeap, *iCacheMemMon);

 	iHintedOutlineCache = new(ELeave) CHintedOutlineCache(iHeap, *iCacheMemMon);

 	iFontTableCache = new(ELeave) CFontTableCache(iHeap, *iCacheMemMon);

 	}

 /** Creates a new CFontStore object.

 Sets iKPixelWidthInTwips and iKPixelHeightInTwips.

 Sets the default bitmap type, used when getting bitmap fonts, to EMonochromeGlyphBitmap.

 Also initialises other private member variable values .

 @param aHeap A pointer to the heap class used for memory allocation.

 @leave KErrNoMemory Insufficient memory available on the heap. */

 EXPORT_C CFontStore *CFontStore::NewL(RHeap* aHeap)

 	{

 	User::LeaveIfNull(aHeap);

 	CFontStore *fontstore = new(ELeave) CFontStore(aHeap);

 	CleanupStack::PushL(fontstore);

 	fontstore->ConstructL();

 	CleanupStack::Pop(fontstore);

 	return fontstore;

 	}

 /** Destructor. */

 EXPORT_C CFontStore::~CFontStore()

 	{

 	// Remove All font files, and Reset associated arrays

 	RemoveFile(KNullUid);

 	iOpenFontRasterizerList.ResetAndDestroy();

 	iShaperFactoryList.ResetAndDestroy();

 	if (iOpenFontSessionCacheList)

 		{

 		iOpenFontSessionCacheList->Delete(iHeap);

 		iHeap->Free(iOpenFontSessionCacheList);

 		}

 	iFs.Close();

     delete iFontTableCache;

     delete iUnhintedOutlineCache;

     delete iHintedOutlineCache;

     delete iCacheMemMon;

 	}

 // local utility functions

 // reads bytes from file, if the requested number of bytes are not available it leaves

 void ReadFromFileL(RFile& aFile, TDes8& aDes, TInt aLength)

 	{

 	User::LeaveIfError(aFile.Read(aDes, aLength));

 	if (aDes.Length() != aLength)

 		{

 		OstTrace0( TRACE_DUMP, _READFROMFILEL, "EOF reading structure from font file, Leave(KErrCorrupt)" );

 		User::Leave(KErrCorrupt);

 		}

 	}

 // local function(s) to read values from buffer & validate them

 TUint TtfTableTagFromBufferL(TDes8& aDes)

 	{

 	TUint value = 0;

 	for (TUint index = 0; index < 4;)

 		{

 		TUint temp = static_cast<TUint>(aDes[index++]);

 		// must be ASCII character between 32 & 126 inclusive (per Apple's TTF specification document)

 		if ( (temp < 32) || (temp > 126) )

 			{

 			OstTrace1( TRACE_DUMP, _TTFTABLETAGFROMBUFFERL, "invalid ASCII character (0x%x) in ttf table tag, Leave(KErrCorrupt)", temp);

 			User::Leave(KErrCorrupt);

 			}

 		value = (value << 8) | temp;

 		}

 	return value;

 	}

 /* Sanity check for TrueType Font, checks that the font tables are sensible.

 */

 void CFontStore::SanityCheckForTtfL(RFile& aFontFile, TUint aFontFileSize, TBool aStrictChecking)

 	{

 	OstTraceExt2( TRACE_DUMP, CFONTSTORE_SANITYCHECKFORTTFL, "TTF File Size is %u (0x%x) bytes", aFontFileSize, aFontFileSize );

 	// check the Offset Table at the start of the file

 	TBuf8<16>	fileBuffer;

 	ReadFromFileL(aFontFile, fileBuffer, 12);

 	TUint numTables = (fileBuffer[4] << 8) | (fileBuffer[5]);

 	TUint searchRange = (fileBuffer[6] << 8) | (fileBuffer[7]);

 	TUint entrySelector = (fileBuffer[8] << 8) | (fileBuffer[9]);

 	TUint rangeShift = (fileBuffer[10] << 8) | (fileBuffer[11]);

 	const TInt tableStart = 12 + (numTables << 4);	// lowest possible address for actual table data

 	if ( (numTables == 0) || (numTables & 0xF0000000) || (tableStart > aFontFileSize) )

 		{

 		OstTrace1( TRACE_DUMP, DUP1_CFONTSTORE_SANITYCHECKFORTTFL, "# of tables (%d) in ttf is invalid, Leave(KErrCorrupt)", numTables );

 		User::Leave(KErrCorrupt);

 		}

 #if defined(_DEBUG) && defined(VERBOSE_DEBUG)

 	// scalar type is 0x00010000 for Windows fonts, other possible values include 0x74727565 and 0x74797031: not checked

 	TUint scalarType = (fileBuffer[0] << 24) | (fileBuffer[1] << 16) | (fileBuffer[2] << 8) | (fileBuffer[3]);

 	RDebug::Print(_L("ttf scalarType is 0x%x, # of tables is %u\n"), scalarType, numTables);

 	RDebug::Print(_L("searchRange is 0x%x, entrySelector is 0x%x, rangeShift is 0x%x\n"), 

 		searchRange, entrySelector, rangeShift);

 #endif

 	// check searchRange, entrySelector & rangeShift values

 	// (some not quite TTF files fail the rangeShift check)

 	if ( (searchRange < 16) || (entrySelector > 24)

 		|| (aStrictChecking && (rangeShift != ( (numTables << 4) - searchRange )) ) )

 		{

 		OstTraceExt4( TRACE_DUMP, DUP2_CFONTSTORE_SANITYCHECKFORTTFL, "searchRange (0x%x), entrySelector (0x%x) or rangeShift (0x%x) invalid for numTables (%d), Leave(KErrCorrupt)", 

 		        searchRange, entrySelector, rangeShift, numTables );

 		User::Leave(KErrCorrupt);

 		}

 	// entrySelector is defined as Log2(Maximum power of 2 <= nmumTables)

 	TUint exp = 1 << entrySelector;		// log to exponent

 	if ( (numTables < exp) || (numTables > (exp << 1)) )

 		{

 		OstTraceExt2( TRACE_DUMP, DUP3_CFONTSTORE_SANITYCHECKFORTTFL, "entrySelector (0x%x) wrong for numTables(%d), Leave(KErrCorrupt)", 

 		        entrySelector, numTables );

 		User::Leave(KErrCorrupt);

 		}

 	// easy checks on the table directory

 	TInt totalFontSize = tableStart;				// accumulated total directories plus table sizes

 	TInt highestTableEnd = 0;						// highest value found for table start plus table length

 	TUint lastTableTag = 0;							// to check that tags are in order

 	TInt tableNum = 0;

 	do 

 		{ // each entry is 16 bytes, (though we don't check the checksum)

 		ReadFromFileL(aFontFile, fileBuffer, 16);

 		TUint tableTag = TtfTableTagFromBufferL(fileBuffer);

 		TUint offset = (fileBuffer[8] << 24) | (fileBuffer[9] << 16) | (fileBuffer[10] << 8) | (fileBuffer[11]);

 		TUint length = (fileBuffer[12] << 24) | (fileBuffer[13] << 16) | (fileBuffer[14] << 8) | (fileBuffer[15]);

 #if defined(_DEBUG) && defined(VERBOSE_DEBUG)

 		RDebug::Print(_L("ttf table tag ('%c%c%c%c'): offset is 0x%x, length is 0x%x\n"), 

 			tableTag >> 24, (tableTag >> 16) & 0x7F, (tableTag >> 8) & 0x7F, tableTag & 0x7F, 

 			offset, length);

 #endif

 		length = (length + 3) & ~3;	// round up, all tables must be a multiple of 4 bytes for checksumming

 		// table Tags must be unique & in order

 		if (tableTag <= lastTableTag)

 			{

 			OstTraceExt4( TRACE_DUMP, DUP4_CFONTSTORE_SANITYCHECKFORTTFL, "ttf table tag ('%c%c%c%c') is out of order, Leave(KErrCorrupt)",

 			        tableTag >> 24, (tableTag >> 16) & 0x7F, (tableTag >> 8) & 0x7F, tableTag & 0x7F);

 			User::Leave(KErrCorrupt);

 			}

 		// the offset must be 4-byte aligned, and after the table directory

 		// offset + length must be bigger than the start offset (!)

 		TInt end = length + offset;

 		if ( (offset & 3) || (offset < tableStart) || (length == 0) || (end < offset) || (end > aFontFileSize))

 			{

 			OstTraceExt2( TRACE_DUMP, DUP5_CFONTSTORE_SANITYCHECKFORTTFL, "offset (0x%x) or length (0x%x) are bad, Leave(KErrCorrupt)",

 			        offset, length );

 			User::Leave(KErrCorrupt);

 			}

 		lastTableTag = tableTag;

 		totalFontSize += length;

 		if (end > highestTableEnd)

 			{

 			highestTableEnd = end;

 			}

 		}

 		while (++tableNum < numTables);

 #if defined(_DEBUG) && defined(VERBOSE_DEBUG)

 	RDebug::Print(_L("last address used by any table is 0x%x, Minimum font file size to hold all tables is 0x%x\n"), 

 			highestTableEnd, totalFontSize);

 #endif

 	// for single font files highestTableEnd & totalFontSize should be the same

 	if (highestTableEnd != totalFontSize)

 		{

 		OstTraceExt2( TRACE_DUMP, DUP6_CFONTSTORE_SANITYCHECKFORTTFL, "Total Font Size (0x%x) is different from end of the last table (0x%x), Leave(KErrCorrupt)",

 		        highestTableEnd, totalFontSize);

 		User::Leave(KErrCorrupt);

 		}

 	}

 /* Sanity checks on font files, currently only knows about TrueType Font files: .ttf and .otf

 Protects FBserv / the client and the rasterizer plug-in from grossly corrupt data.

 @leave KErrCorrupt if the font tables are daft

 */

 void CFontStore::SanityCheckFontFileL(TParse& aParse)

 	{

 	// try to open the file and getting the file size

 	RFile fontFile;

 	const TInt openError = fontFile.Open(iFs, aParse.FullName(), EFileRead | EFileShareReadersOnly);

 #ifdef _DEBUG

 	if (KErrNone != openError)

 		{

 		const TDesC& fileName = aParse.FullName();

 		RDebug::Print(_L("Sanity checking font file \"%S\", file open gave error %d\n"), &fileName, openError);

 		}

 #endif

 	User::LeaveIfError(openError);

 	CleanupClosePushL(fontFile);

 	TInt fontFileSize = 0;

 	User::LeaveIfError(fontFile.Size(fontFileSize));

 	if (fontFileSize == 0)

 		{ // no font can be zero length!

 #ifdef _DEBUG

 		RDebug::Print(_L("font file size (%i) is zero\n"), fontFileSize);

 #endif

 		User::Leave(KErrCorrupt);

 		}

 	else

 		{

 		const TDesC& fileExt = aParse.Ext();

 		// TrueType fonts

 		_LIT(KFntStoreTrueTypeExtension,".ttf");

 		// OpenType fonts

 		_LIT(KFntStoreOpenTypeExtension,".otf");

 		// other font files that follow TTF format

 		_LIT(KFntStoreCccFontFileExtension,".ccc");

 		if ( (0 == fileExt.CompareF(KFntStoreTrueTypeExtension)) || (0 == fileExt.CompareF(KFntStoreOpenTypeExtension)) )

 			{ // uses TrueType file format, perform strict format check

 			SanityCheckForTtfL(fontFile, fontFileSize, ETrue);

 			}

 		else if (0 == fileExt.CompareF(KFntStoreCccFontFileExtension))

 			{ // uses nearly TrueType file format, perform slightly less strict format check

 			SanityCheckForTtfL(fontFile, fontFileSize, EFalse);

 			}

 		// extendible if required for other font file types ...

 		}

 	CleanupStack::PopAndDestroy(&fontFile);

 	}

 /** Finds or creates a font file object to support a font file. The specified font

 file must be accessible to any process, i.e. not located inside an

 application's private directory.

 If an appropriate font file object exists then no new open font file is created. 

 In this case the reference count of the font file object is incremented.

 Notes:

 If aName is recognised as an open font file, creates a COpenFontFile, which 

 will manage the font file specified by aName, and adds it to the file store's 

 list of open font files.

 The list of open font files is used when getting the nearest font for a font 

 specification (i.e. by the GetNearestFont...() functions of this class) if 

 the font is generated via a rasterizer.

 The appropriate rasterizer, which supports the font format of the font file, 

 is used to generate the open font file using COpenFontRasterizer::NewFontFileL().

 If aName is not recognised as an open font file then CFontStoreFile tries to open

 the file as a Symbian Bitmap font.

 @param aName The full path and filename of the font file to be supported.

 @return The UID of the font file object supporting aName.

 @leave KErrNotSupported if the file is not recognised at all

 @leave KErrCorrupt if the font file data does not make sense

 @leave or another system-wide error

 */

 EXPORT_C TUid CFontStore::AddFileL(const TDesC& aName)

 	{

 	TParse fontFilename;

 	User::LeaveIfError(iFs.Parse(aName, fontFilename));

 	// increment reference count if font file is already loaded

 	TUid fontUid = KNullUid;

 	if (IncRefCountOfLoadedFont(fontFilename, fontUid))

 		{

 		return fontUid;

 		}

 	// Do not validate fonts on Z: (assumed to be ROM created with valid fonts)

 	if (!FileIsOnZ(fontFilename))

 		{

 		// file is not open - check that the file exists and has a plausible content

 		SanityCheckFontFileL(fontFilename);

 		}

 	AddSanityCheckedFontL(fontFilename, fontUid);

 	return fontUid;

 	}

 /**

 Finds or creates a font file object to support a font file.

 @param aFileName The filename to check

 @param aUid The list to check

 @see CFontStore::AddFileL

 */

 void CFontStore::AddSanityCheckedFontL(const TParse& aFileName, TUid& aUid)

 	{

 	// Try loading the file as an Open Font

 	if (!LoadFileAsOpenFontL(aFileName, aUid))

 		{

 		// It could not be recognised as an Open Font file so load it as an EPOC bitmap font file.

 		// (This always succeeds or Leaves.)

 		aUid = LoadFileAsBitmapFontL(aFileName);

 		}

 	}

 // Remove a Font File - called via the Cleanup Stack if a leave occurs during font install

 void CFontStore::CleanupRemoveFontFile(TAny* aCleanupInfo)

 	{

 	TCleanupRemoveFontFile* cleanupInfo = (TCleanupRemoveFontFile *) aCleanupInfo;

 	cleanupInfo->iFontStore->RemoveFile(cleanupInfo->iFontUid);

 	}

 /** Search through the rasterizers for one that will open the font filename.

 Can leave if the rasterizer encounters an error, such as unexpected end of file, nonsense data, no memory.

 @param aName full filename to open

 @param aFontUid set to the font file UID if it is already loaded

 @return ETrue if the font file is loaded, otherwise EFalse

 @internalComponent

 */

 TBool CFontStore::LoadFileAsOpenFontL(const TParse& aFileName, TUid& aFontUid)

 	{

 	const TDesC& fullName = aFileName.FullName();

 	// ask each of the rasterizers in turn to create a COpenFontFile object.

 	const TInt rasterizerCount = iOpenFontRasterizerList.Count();

 	for (TInt index = 0; index < rasterizerCount; index++)

 		{

 		COpenFontFile* openFontFile = iOpenFontRasterizerList[index]->NewFontFileL(iOpenFontUid, fullName, iFs);

 		if (NULL != openFontFile)

 			{

 			/* Uids for Open Fonts are allocated in order; the

 			one for the COpenFontFile just created won't match any existing one.

 			(When a file is removed, the fake Uid will match, because the one that was returned here is used.)

 			*/

 			CleanupStack::PushL(openFontFile);

 			openFontFile->SetFontStoreL(this);

 			iOpenFontFileList.AppendL(openFontFile);

 			openFontFile->IncRefCount();

 			CleanupStack::Pop(openFontFile);

 			TInt typefaceAddError = AddTypefacesToSupportList(openFontFile);

 			if (typefaceAddError)

 				{

 				// cleanup

 				RemoveFile(openFontFile->Uid());

 				// throw the error

 				User::Leave(typefaceAddError);

 				}

 			/*

 			iOpenFontUid is the fake Uid used for new font files. It is made modulo a 'zillion' (2^28)

 			so that it cannot conflict with real Uids, which are >= 2^28. It starts at 1 so that

 			it does not conflict with the value 0 (KNullUid) which is used as a sentinel in

 			CFontStore::RemoveFileL.

 			*/

 			++iOpenFontUid;

 			iOpenFontUid = iOpenFontUid % 0x1000000;

 			aFontUid = openFontFile->Uid();

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 /** Search loaded fonts for filename, and increment the reference count

 @param aParse full filename to search for

 @return the font file UID

 @leave KErrNotSupported or another system wide error code

 @internalComponent

 */

 TUid CFontStore::LoadFileAsBitmapFontL(const TParse& aParse)

 	{

 	// open the file, presuming it is a bitmap font

 	CFontStoreFile* fontStoreFile = CFontStoreFile::NewL(aParse, iFs);

 	// See if a font with this UID is already open

 	TInt match = FindBitmapFontFileIndexByUid(fontStoreFile->iCollectionUid);