/*

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

*

*/

#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>

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 (TInt)aAny - (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(const TInt aOffset, TUint8* aHeapBase)

    {

    if (aOffset && aHeapBase)

        {

        return (TAny*)(aOffset + (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),