/*

 * Copyright (c) 1996-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 <s32file.h>

 #include <fntstore.h>

 #include "FNTBODY.H"

 #include <graphics/openfontconstants.h>

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "FNTBODYTraces.h"

 #endif

 CFontStoreFile::CFontStoreFile()

  :	iCollectionUid(KNullUid),

 	iUsageCount(1),

 	iFileStore(NULL),

 	iFileAddress(0),

 	iDataStreamId(KNullStreamId)

 	{

 	}

 void CFontStoreFile::ConstructL(const TParse& aParse,RFs& aFs)

 	{

 	TInt drive;

 	User::LeaveIfError(RFs::CharToDrive(aParse.Drive()[0], drive));

 	TDriveInfo driveinfo;

 	User::LeaveIfError(aFs.Drive(driveinfo, drive));

 	RFile file;

 	// store the filename

 	iFullName = aParse.FullName().AllocL();

 	User::LeaveIfError(file.Open(aFs, *iFullName, EFileStream | EFileRead | EFileShareReadersOnly));

 	// check to see if the fonts are stored on ROM.  Note that NAND != rom so font files in NAND devices

 	// must be handled as if they were in RAM.  A NULL pointer returned by IsFileInRom means its RAM

 	if (aFs.IsFileInRom(*iFullName)!=NULL)

 		{

 		// fonts are stored on a XIP (execute in place) device

 		TInt ret = file.Seek(ESeekAddress, iFileAddress);

 		if (ret != KErrNone)

 			{

 			file.Close();

 			User::Leave(ret);

 			}

 		}

 	// convert RFile into a CDirectFileStore

 	CDirectFileStore* fileStore = CDirectFileStore::FromLC(file);

 	if (fileStore->Type()[1] != TUid::Uid(KFontStoreFileUidVal))

 		User::Leave(KErrNotSupported);

 	TStreamId headerid = fileStore->Root();

 	RStoreReadStream stream;

 	stream.OpenLC(*fileStore, headerid);

 	TInt fnttranversion = stream.ReadInt32L();

 	// This works for version 42 (with new metrics) and for earlier versions 

 	// which will synthesize the required metrics. It may have to be changed 

 	// if the version number is incremented again.

 	if (fnttranversion < (KFnttranVersion - 1)  && fnttranversion != KFnttran7650Version) 

 		User::Leave(KErrNotSupported);

 	iFontVersion = fnttranversion;

 	stream >> iCollectionUid;

 	iKPixelAspectRatio = stream.ReadInt32L();

 	stream >> iDataStreamId;

 	CleanupStack::PopAndDestroy(&stream);	// close root stream

 	// ensure font data stream can be opened

 	stream.OpenLC(*fileStore, iDataStreamId);

 	CleanupStack::PopAndDestroy(&stream);	// close font stream

 	// transfer ownership of fileStore

 	CleanupStack::Pop(fileStore);

 	iFileStore = fileStore;

 	}

 CFontStoreFile* CFontStoreFile::NewL(const TParse& aParse, RFs& aFs)

 	{

 	CFontStoreFile* fontstorefile = new(ELeave) CFontStoreFile;

 	CleanupStack::PushL(fontstorefile);

 	fontstorefile->ConstructL(aParse, aFs);

 	CleanupStack::Pop();

 	return fontstorefile;

 	}

 CFontStoreFile::~CFontStoreFile()

 	{

 	delete iFullName;

 	iFullName = NULL;

 	delete iFileStore;

 	iFileStore = NULL;

 	}

 TBitmapCodeSection::TBitmapCodeSection()

  :	TCodeSection(),

 	iCharacterData(),

 	iBitmapData()

 	{

 	}

 //This method is called  from CFontBitmap::InternalizeL.

 //We have to read stream IDs from the stream, not offsets.

 //Obviously the method is called once per life time of 

 //CFontBitmap instance.

 void TBitmapCodeSection::InternalizeL(RReadStream &aStream)

 	{

 	iStart = aStream.ReadUint16L();

 	iEnd = aStream.ReadUint16L();

 	aStream >> iCharacterData.iOffsetsId;

 	aStream >> iBitmapData.iBitmapId; 

 	}

 //This method is called  from CFontBitmap::RestoreComponentsL - 

 //if the CFontBitmap instance is in RAM and CFontBitmap::iComponentsRestored is EFalse.

 //We use here stream IDs, not offsets.

 //If the memory allocation for the offsets doesn't fail - aAllocMemCounter is incremented

 //After calling of TBitmapCodeSection::InternalizeOffsetsL character metrics streamID is no more valid - 

 //we have valid character metrics offset into RAM memory.

 void TBitmapCodeSection::InternalizeOffsetsL(const CStreamStore& aStreamStore, RHeap* aHeap, TInt& aAllocMemCounter)

 	{

 	RStoreReadStream stream;

 	stream.OpenLC(aStreamStore, iCharacterData.iOffsetsId);

 	TInt size = stream.ReadInt32L();

 	TBitmapFontCharacterOffset* characterOffsetsList = (TBitmapFontCharacterOffset*)aHeap->AllocL(sizeof(TBitmapFontCharacterOffset) * size);

 	aAllocMemCounter++;

 	iCharacterData.iCharacterOffsetsListOffset = TInt(characterOffsetsList) - TInt(this);

 	TBitmapFontCharacterOffset* pEnd = characterOffsetsList + size;

 	for (TBitmapFontCharacterOffset* p = characterOffsetsList; p < pEnd; p++)

 		{

 		p->InternalizeL(stream);

 		}

 	CleanupStack::PopAndDestroy();

 	}

 //This method is called  from CFontBitmap::RestoreComponentsL - 

 //if the CFontBitmap instance is in RAM and CFontBitmap::iComponentsRestored is EFalse.

 //We use here stream IDs, not offsets.

 //If the memory allocation for the bitmap doesn't fail - aAllocMemCounter is incremented

 //After calling of TBitmapCodeSection::InternalizeBitmapL bitmap streamID is no more valid - 

 //we have valid bitmap offset into RAM memory.

 void TBitmapCodeSection::InternalizeBitmapL(const CStreamStore& aStreamStore, RHeap* aHeap, TInt& aAllocMemCounter)

 	{

 	RStoreReadStream stream;

 	stream.OpenLC(aStreamStore, iBitmapData.iBitmapId);

 	TInt size = stream.ReadInt32L();

 	TUint8* bitmap = (TUint8*)aHeap->AllocL(size);

 	aAllocMemCounter++;

 	iBitmapData.iBitmapOffset = TInt(bitmap) - TInt(this);

 	stream.ReadL(bitmap, size);

 	CleanupStack::PopAndDestroy();

 	}

 //This method is called from CFontBitmap::InternalizeL if the

 //CFontBitmap instance is in ROM.

 //We use here stream IDs to calculate offsets.

 //After calling of TBitmapCodeSection::FixUpComponents streamIDs are no more valid - 

 //we have valid offsets into ROM memory.

 //Obviously the method is called once per life time of 

 //CFontBitmap instance.

 void TBitmapCodeSection::FixUpComponents(TInt aFileAddress)

 	{

 	TBitmapFontCharacterOffset* characterOffsetsList = (TBitmapFontCharacterOffset*) (aFileAddress + sizeof(TInt) + iCharacterData.iOffsetsId);

 	iCharacterData.iCharacterOffsetsListOffset = TInt(characterOffsetsList);

 	TUint8* bitmap = (TUint8*) (aFileAddress + sizeof(TInt) + iBitmapData.iBitmapId);

 	iBitmapData.iBitmapOffset = TInt(bitmap);

 	}

 //This method is caled from CFontBitmap::DeleteComponents(),

 //only if the CFontBitmap instance is in RAM.

 void TBitmapCodeSection::DeleteOffsets(RHeap* aHeap)

 	{

 	TBitmapFontCharacterOffset*  charactersOffsetsList = CharacterOffsetsList(ETrue);

 	if(TUint32(this) != TUint32(charactersOffsetsList))

 		{

 		aHeap->Free(charactersOffsetsList);

 		}

 	}

 //This method is caled from CFontBitmap::DeleteComponents(),

 //only if the CFontBitmap instance is in RAM.

 void TBitmapCodeSection::DeleteBitmap(RHeap* aHeap)

 	{

 	TUint8* bitmap = Bitmap(ETrue);

 	if(TUint32(this) != TUint32(bitmap))

 		{

 		aHeap->Free(bitmap);

 		}

 	}

 TBitmapFontCharacterOffset* TBitmapCodeSection::CharacterOffsetsList(TBool aIsInRAM) const

 	{

 	return reinterpret_cast <TBitmapFontCharacterOffset*> 

 		(iCharacterData.iCharacterOffsetsListOffset + (aIsInRAM ? TInt(this) : 0));

 	}

 TUint8* TBitmapCodeSection::Bitmap(TBool aIsInRAM) const

 	{

 	return reinterpret_cast <TUint8*> 

 		(iBitmapData.iBitmapOffset + (aIsInRAM ? TInt(this) : 0));

 	}

 TCharacterMetricsTable::TCharacterMetricsTable(RHeap* aHeap)

  :	iHeap(aHeap),

 	iMetricsStartId(KNullStreamId),

 	iCharacterMetricsStartPtr(0),

 	iNumberOfMetrics(0),

 	iMetricsOnHeap(EFalse)

 	{}

 void TCharacterMetricsTable::InternalizeL(RReadStream& aStream)

 	{

 	iMetricsStartId = aStream.ReadInt32L();

 	iNumberOfMetrics = aStream.ReadInt32L();

 	}

 void TCharacterMetricsTable::InternalizeMetricsL(RReadStream& aStream)

 	{

 	aStream.ReadInt32L(); // size

 	TBitmapFontCharacterMetrics* charactermetricslist = static_cast<TBitmapFontCharacterMetrics*>(iHeap->AllocL(sizeof(TBitmapFontCharacterMetrics) * iNumberOfMetrics));

 	iMetricsOnHeap = ETrue;

 	// Offset from this to location on the heap ('cos the file is not in ROM)

 	iCharacterMetricsStartPtr = reinterpret_cast<TInt>(charactermetricslist) - reinterpret_cast<TInt>(this);

 	TBitmapFontCharacterMetrics* pEnd = charactermetricslist + iNumberOfMetrics;

 	for (TBitmapFontCharacterMetrics* p = charactermetricslist; p < pEnd; p++)

 		{

 		p->InternalizeL(aStream);

 		}

 	}

 void TCharacterMetricsTable::RestoreL(const CStreamStore& aStreamStore)

 	{

 	if (iCharacterMetricsStartPtr == 0)

 		{	// We haven't already read it in from RAM file

 		RStoreReadStream stream;

 		stream.OpenLC(aStreamStore, iMetricsStartId);

 		InternalizeMetricsL(stream);

 		CleanupStack::PopAndDestroy();

 		}

 	}

 void TCharacterMetricsTable::FixUp(TInt aFileAddress)

 	{

 	TBitmapFontCharacterMetrics* charactermetricslist = reinterpret_cast<TBitmapFontCharacterMetrics*>(aFileAddress + sizeof(TInt) + iMetricsStartId.Value());

 	iCharacterMetricsStartPtr = TInt(charactermetricslist);	// Ptr to location in a ROM file

 	iMetricsStartId = KNullStreamId;

 	iMetricsOnHeap = EFalse;

 	}

 void TCharacterMetricsTable::Delete()

 	{	// This routine is only called if the font file is in RAM, not ROM, and therefore the metrics have been stashed on the heap

     if (iMetricsOnHeap && iCharacterMetricsStartPtr)

         {

         iHeap->Free(reinterpret_cast<TAny*>(MetricsFromOffset(0)));

         iCharacterMetricsStartPtr = 0;

         iMetricsOnHeap = EFalse;

         }

 	}

 const TBitmapFontCharacterMetrics* TCharacterMetricsTable::Metric(TInt aIndex) const

 	{

 	if ((aIndex < 0) || (aIndex > iNumberOfMetrics))

 	    {

 	    OstTraceExt2( TRACE_FATAL, TCHARACTERMETRICSTABLE_METRIC, "TCharacterMetricsTable::Metric, aIndex=%d, iNumberOfMetrics=%d, Panic(EFntMetricsIndexOutOfBounds)", aIndex, iNumberOfMetrics);

 	    __ASSERT_DEBUG(0, Panic(EFntMetricsIndexOutOfBounds));

 	    }

     // Sometimes the start ptr is to a metrics heap item and sometimes it points into a ROM file

     if (iMetricsOnHeap)

         {

         // Start ptr is to metrics heap item

         return MetricsFromOffset(aIndex);

         }

     else

         {

         // Start ptr is to a file in ROM

         return reinterpret_cast<const TBitmapFontCharacterMetrics*> (iCharacterMetricsStartPtr + (aIndex * sizeof(TBitmapFontCharacterMetrics)));

         }

 	}

 TInt TCharacterMetricsTable::NumberOfMetrics() const

 	{

 	return iNumberOfMetrics;

 	}

 TBitmapFontCharacterMetrics* TCharacterMetricsTable::MetricsFromOffset(TInt aIndex) const

     {

     __ASSERT_DEBUG(iMetricsOnHeap,Panic(EFntMetricsNotOnHeap));

     return reinterpret_cast<TBitmapFontCharacterMetrics*>(reinterpret_cast<TInt>(this) + iCharacterMetricsStartPtr+ (aIndex * sizeof(TBitmapFontCharacterMetrics)));

     }

 CFontBitmap::CFontBitmap(RHeap* aHeap, CFontStoreFile* aFontStoreFile)

  :	iHeap(aHeap),

 	iFontStoreFileOffset(0),

 	iUid(KNullUid),

 	iPosture(0),

 	iStrokeWeight(0),

 	iIsProportional(0),

 	iIsInRAM(!aFontStoreFile->iFileAddress),

 	iUsageCount(1),

 	iCellHeightInPixels(0),

 	iAscentInPixels(0),

 	iMaxCharWidthInPixels(0),

 	iMaxNormalCharWidthInPixels(0),

 	iBitmapEncoding(0),

 	iNumCodeSections(0),

 	iCodeSectionListOffset(0),

 	iCharacterMetricsTable(aHeap),

 	iComponentsRestored(EFalse),

 	iAllocMemCounter_Offsets(0),

 	iAllocMemCounter_Bitmaps(0),

 	iFontCapitalAscent(0),

 	iFontMaxAscent(0),

 	iFontStandardDescent(0),

 	iFontMaxDescent(0),

 	iFontLineGap(0)

 	{

 	iFontStoreFileOffset = TInt(aFontStoreFile) - TInt(this);

 	}

 void CFontBitmap::InternalizeL(RReadStream &aStream, TInt aFontVersion)

 	{

 	aStream >> iUid;

 	iPosture = aStream.ReadInt8L();

 	iStrokeWeight = aStream.ReadInt8L();

 	iIsProportional = aStream.ReadInt8L();

 	iCellHeightInPixels = aStream.ReadInt8L();

 	iAscentInPixels = aStream.ReadInt8L();

 	iMaxCharWidthInPixels = aStream.ReadInt8L();

 	iMaxNormalCharWidthInPixels = aStream.ReadInt8L();

 	if ( aFontVersion  >= KFnttranVersion )

 		{ // read the new metrics in

 		iFontCapitalAscent = aStream.ReadInt8L();

 		iFontMaxAscent = aStream.ReadInt8L();

 		iFontStandardDescent = aStream.ReadInt8L();

 		iFontMaxDescent = aStream.ReadInt8L();

 		iFontLineGap = aStream.ReadInt8L();

 		}

 	else // synthesize the extra metrics (data compatibility with third party bitmap fonts for old phones)

 		{

 		iFontMaxAscent = iFontCapitalAscent = iAscentInPixels;

 		iFontMaxDescent = iFontStandardDescent = iCellHeightInPixels - iAscentInPixels;

 		iFontLineGap = ( ( iCellHeightInPixels * 12 ) + 5) / 10;  // 1.2 times design height

 		}	

 	iBitmapEncoding = aStream.ReadInt32L();

 	iCharacterMetricsTable.InternalizeL(aStream);

 	const TBool fixup = FontStoreFile()->iFileAddress;

 	if (fixup)

 		{

 		iCharacterMetricsTable.FixUp(FontStoreFile()->iFileAddress);

 		}

 	iNumCodeSections = aStream.ReadInt32L();

 	TBitmapCodeSection* codesectionlist = (TBitmapCodeSection*)User::LeaveIfNull(iHeap->AllocL(iNumCodeSections * sizeof(TBitmapCodeSection)));

 	iCodeSectionListOffset = TInt(codesectionlist) - TInt(this);

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

 		{

 		new(codesectionlist + i) TBitmapCodeSection;

 		codesectionlist[i].InternalizeL(aStream);

 		if (fixup)

 			codesectionlist[i].FixUpComponents(FontStoreFile()->iFileAddress);

 		}

 	}

 void CFontBitmap::UseL()

 	{

 	// Note object is created with a Usage Count of 1.

 	// So incrementing to 2 normally indicates the first external reference.

 	iUsageCount++;

 	if (iUsageCount == 2)

 		{

 		RestoreComponentsL();

 		}

 	}

 void CFontBitmap::Release()

 	{

 	iUsageCount--;

 	if (!iUsageCount)

 		{ // object and all its users have closed

 		delete this;

 		}

 	}

 /*

 Get the metrics for a given character.

 Return aBytes as null if the character aCode doesn't exist in the font.

 */

 TBitmapFontCharacterMetrics CFontBitmap::CharacterMetrics(TInt aCode, const TUint8*& aBytes) const

 	{

  	const TBitmapCodeSection* matchSection = NULL;

 	const TBitmapCodeSection* const lastSection = CodeSectionList() + iNumCodeSections - 1;

 	TBitmapFontCharacterOffset offset;

 	aBytes = NULL;

 	TBitmapFontCharacterMetrics metrics;

 	const TBitmapCodeSection* startSearchBand = CodeSectionList();

 	TInt numCodeSectionsRemaining = iNumCodeSections;

 	while (numCodeSectionsRemaining >= 1)

 		{

 		TInt halfNumCodeSectionsRemaining = numCodeSectionsRemaining/2;

 		const TBitmapCodeSection* centralSearchBand = startSearchBand+halfNumCodeSectionsRemaining;

 		if ((aCode >= centralSearchBand->iStart) && (aCode <= centralSearchBand->iEnd))

 			{

 			matchSection = centralSearchBand;

 			break;

 			}

 		else if ((aCode < centralSearchBand->iStart) || (centralSearchBand == lastSection))

 			numCodeSectionsRemaining = halfNumCodeSectionsRemaining;

 		else

 			{

 			startSearchBand = centralSearchBand + 1;

 			numCodeSectionsRemaining -= halfNumCodeSectionsRemaining + 1;

 			}

 		}

 	if (matchSection)

 		{

 		offset =* ((matchSection->CharacterOffsetsList(iIsInRAM)) + (aCode-matchSection->iStart));

 		// Fill characters within code section.

 		// Recursive call ensures that a valid metric is always returned.

 		if (offset.iBitmapOffset == KFillCharacterOffset)

 			{

 			return CharacterMetrics(KReplacementCharacter, aBytes);

 			}

 		aBytes = matchSection->Bitmap(iIsInRAM) + offset.iBitmapOffset;

 		// retrieve metric index from encoded 1 or 2 bytes

 		TInt index = 0;

 		TUint8 byte1 = (TUint8)*aBytes;

 		const TInt switchMask = 0x1;

 		const TBool oneByteIndex =! (byte1 & switchMask);

 		byte1 = TUint8(byte1 >> 1);

 		if (oneByteIndex)

 			{

 			index = byte1;

 			aBytes += 1;

 			}

 		else

 			{

 			const TUint8 byte2 = (TUint8)(*(aBytes + 1));

 			index = byte1 + (byte2 * 128);

 			aBytes += 2;

 			}

 		// Copy metric from table

 		metrics =* iCharacterMetricsTable.Metric(index);

 		}

 	return metrics;

 	}

 void CFontBitmap::operator delete(TAny *aThis)

 	{

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

 		{

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

 		}

 	}

 void CFontBitmap::SetPosture(TFontPosture aPosture)

 	{

 	iPosture = (TInt8)aPosture;

 	}

 TFontPosture CFontBitmap::Posture() const

 	{

 	return (TFontPosture)iPosture;	 // iPosture is always smaller than TFontPosture

 	}

 void CFontBitmap::SetStrokeWeight(TFontStrokeWeight aStrokeWeight)

 	{

 	iStrokeWeight = (TInt8)aStrokeWeight;

 	}

 TFontStrokeWeight CFontBitmap::StrokeWeight() const

 	{

 	return (TFontStrokeWeight)iStrokeWeight;

 	}

 void CFontBitmap::SetIsProportional(TBool aIsProportional)

 	{

 	iIsProportional = (TInt8)aIsProportional;

 	}

 TBool CFontBitmap::IsProportional() const

 	{

 	return iIsProportional;

 	}

 CFontStoreFile* CFontBitmap::FontStoreFile() const

 	{

 	TInt fsf = TInt(this) + iFontStoreFileOffset;

 	return (CFontStoreFile*)fsf;

 	}

 CFontBitmap::~CFontBitmap()

 	{

 	DeleteComponents();

 	TBitmapCodeSection* codeSectionList = CodeSectionList();

 	if(TUint32(this) != TUint32(codeSectionList))

 		{

 		iHeap->Free(codeSectionList);

 		}

 	iCodeSectionListOffset = 0;

 	}

 //We have to count how many offsets and bitmaps are allocated successfully because if

 //some of codesection's Internalize..L fails we have to deallocate the right amount of 

 //data.

 void CFontBitmap::RestoreComponentsL()

 	{

 	if (iIsInRAM)

 		{

 		if(!iComponentsRestored)

 			{

 			iAllocMemCounter_Offsets = 0;

 			iAllocMemCounter_Bitmaps = 0;

 			CStreamStore& store =* FontStoreFile()->iFileStore;

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

 				{

 				CodeSectionList()[i].InternalizeOffsetsL(store, iHeap, iAllocMemCounter_Offsets);

 				CodeSectionList()[i].InternalizeBitmapL(store, iHeap, iAllocMemCounter_Bitmaps);

 				}

 			iCharacterMetricsTable.RestoreL(store);

 			}

 		iComponentsRestored = ETrue;

 		}

 	}

 void CFontBitmap::DeleteComponents()

 	{

 	if (iIsInRAM)

 		{

 		TInt i;

 		for (i = 0; i < iAllocMemCounter_Offsets; i++)

 			{

 			CodeSectionList()[i].DeleteOffsets(iHeap);

 			}

 		for (i = 0; i < iAllocMemCounter_Bitmaps; i++)

 			{

 			CodeSectionList()[i].DeleteBitmap(iHeap);

 			}

 		iCharacterMetricsTable.Delete();

 		}

 	iAllocMemCounter_Offsets = 0;

 	iAllocMemCounter_Bitmaps = 0;

 	iComponentsRestored = EFalse;

 	}

 TBitmapCodeSection* CFontBitmap::CodeSectionList() const

 	{

 	TInt bcs = TInt(this) + iCodeSectionListOffset;

 	return (TBitmapCodeSection*)bcs;

 	}

 TTypefaceFontBitmap::TTypefaceFontBitmap()

  :	iTypeface(NULL),

 	iFontBitmap(NULL),

 	iHeightFactor(1),

 	iWidthFactor(1)

 	{

 	}

 TTypefaceFontBitmap::TTypefaceFontBitmap(TTypeface* aTypeface,CFontBitmap* aFontBitmap)

  :	iTypeface(aTypeface),

 	iFontBitmap(aFontBitmap),

 	iHeightFactor(1),

 	iWidthFactor(1)

 	{

 	}

 TInt TTypefaceFontBitmap::HeightInPixels() const

 	{

 	return iFontBitmap->iCellHeightInPixels * iHeightFactor;

 	}