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