/*

 * 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_OLD.H"

 #include <graphics/openfontconstants.h>

 TBitmapCodeSectionOld::TBitmapCodeSectionOld(RHeap* aHeap)

  :	TCodeSection(),

 	iHeap(aHeap),

 	iOffsetsId(),

 	iCharacterOffsetsListOffset(0),

 	iBitmapId(),

 	iBitmapOffset(0)

 	{

 	}

 void TBitmapCodeSectionOld::InternalizeL(RReadStream &aStream)

 	{

 	iStart = aStream.ReadUint16L();

 	iEnd = aStream.ReadUint16L();

 	aStream >> iOffsetsId;

 	aStream >> iBitmapId; 

 	}

 void TBitmapCodeSectionOld::RestoreComponentsL(const CStreamStore& aStreamStore)

 	{

 	if (iCharacterOffsetsListOffset == 0)

 		{

 		RStoreReadStream stream;

 		stream.OpenLC(aStreamStore, iOffsetsId);

 		InternalizeOffsetsL(stream);

 		CleanupStack::PopAndDestroy();

 		}

 	if (iBitmapOffset == 0)

 		{

 		RStoreReadStream stream;

 		stream.OpenLC(aStreamStore, iBitmapId);

 		InternalizeBitmapL(stream);

 		CleanupStack::PopAndDestroy();

 		}

 	}

 void TBitmapCodeSectionOld::FixUpComponents(TInt aFileAddress)

 	{

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

 	iCharacterOffsetsListOffset = TInt(characterOffsetsList);

 	iOffsetsId = KNullStreamId;

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

 	iBitmapOffset = TInt(bitmap);

 	}

 void TBitmapCodeSectionOld::DeleteComponents()

 	{

 	if (iCharacterOffsetsListOffset)

 		{

 		iHeap->Free(CharacterOffsetsList());

 		iCharacterOffsetsListOffset = 0;

 		}

 	if (iBitmapOffset)

 		{

 		iHeap->Free(Bitmap());

 		iBitmapOffset = 0;

 		}

 	}

 void TBitmapCodeSectionOld::operator delete(TAny *aThis)

 	{

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

 		{

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

 		}

 	}

 void TBitmapCodeSectionOld::InternalizeOffsetsL(RReadStream &aStream)

 	{

 	TInt size = aStream.ReadInt32L();

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

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

 	TBitmapFontCharacterOffset* pEnd = characterOffsetsList + size;

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

 		{

 		p->InternalizeL(aStream);

 		}

 	}

 void TBitmapCodeSectionOld::InternalizeBitmapL(RReadStream &aStream)

 	{

 	TInt size = aStream.ReadInt32L();

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

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

 	aStream.ReadL(bitmap, size);

 	}

 TBitmapFontCharacterOffset* TBitmapCodeSectionOld::CharacterOffsetsList() const

 	{

 	if (iOffsetsId == KNullStreamId)

 		{

 		return (TBitmapFontCharacterOffset*)iCharacterOffsetsListOffset;

 		}

 	TInt charOffsList = TInt(this) + iCharacterOffsetsListOffset;

 	return (TBitmapFontCharacterOffset*)charOffsList;

 	}

 TUint8* TBitmapCodeSectionOld::Bitmap() const

 	{

 	if (iOffsetsId == KNullStreamId)

 		{

 		return (TUint8*)iBitmapOffset;

 		}

 	TInt bitmap = TInt(this)+iBitmapOffset;

 	return (TUint8*)bitmap;

 	}

 CFontBitmapOld::CFontBitmapOld(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)

 	{

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

 	}

 void CFontBitmapOld::InternalizeL(RReadStream &aStream)

 	{

 	aStream >> iUid;

 	iPosture = aStream.ReadInt8L();

 	iStrokeWeight = aStream.ReadInt8L();

 	iIsProportional = aStream.ReadInt8L();

 	iCellHeightInPixels = aStream.ReadInt8L();

 	iAscentInPixels = aStream.ReadInt8L();

 	iMaxCharWidthInPixels = aStream.ReadInt8L();

 	iMaxNormalCharWidthInPixels = aStream.ReadInt8L();

 	iBitmapEncoding = aStream.ReadInt32L();

 	iCharacterMetricsTable.InternalizeL(aStream);

 	const TBool fixup = FontStoreFile()->iFileAddress;

 	if (fixup)

 		{

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

 		}

 	iNumCodeSections = aStream.ReadInt32L();

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

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

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

 		{

 		new(codesectionlist + i) TBitmapCodeSectionOld(iHeap);

 		codesectionlist[i].InternalizeL(aStream);

 		if (fixup)

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

 		}

 	}

 void CFontBitmapOld::UseL()

 	{

 	iUsageCount++;

 	if (iUsageCount == 2)

 		RestoreComponentsL();

 	}

 void CFontBitmapOld::Release()

 	{

 	iUsageCount--;

 	if (!iUsageCount)

 		{

 		delete this;

 		}

 	}

 /*

 Get the metrics for a given character.

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

 */

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

 	{

  	const TBitmapCodeSectionOld* matchSection = NULL;

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

 	TBitmapFontCharacterOffset offset;

 	aBytes = NULL;

 	TBitmapFontCharacterMetrics metrics;

 	const TBitmapCodeSectionOld* startSearchBand = CodeSectionList();

 	TInt numCodeSectionsRemaining = iNumCodeSections;

 	while (numCodeSectionsRemaining >= 1)

 		{

 		TInt halfNumCodeSectionsRemaining = numCodeSectionsRemaining/2;

 		const TBitmapCodeSectionOld* 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()) + (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() + 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 CFontBitmapOld::operator delete(TAny *aThis)

 	{

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

 		{

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

 		}

 	}

 void CFontBitmapOld::SetPosture(TFontPosture aPosture)

 	{

 	iPosture = (TInt8)aPosture;

 	}

 TFontPosture CFontBitmapOld::Posture()

 	{

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

 	}

 void CFontBitmapOld::SetStrokeWeight(TFontStrokeWeight aStrokeWeight)

 	{

 	iStrokeWeight = (TInt8)aStrokeWeight;

 	}

 TFontStrokeWeight CFontBitmapOld::StrokeWeight()

 	{

 	return (TFontStrokeWeight)iStrokeWeight;

 	}

 void CFontBitmapOld::SetIsProportional(TBool aIsProportional)

 	{

 	iIsProportional = (TInt8)aIsProportional;

 	}

 TBool CFontBitmapOld::IsProportional()

 	{

 	return iIsProportional;

 	}

 CFontStoreFile* CFontBitmapOld::FontStoreFile() const

 	{

 	TInt fsf = TInt(this) + iFontStoreFileOffset;

 	return (CFontStoreFile*)fsf;

 	}

 CFontBitmapOld::~CFontBitmapOld()

 	{

 	DeleteComponents();

 	iHeap->Free(CodeSectionList());

 	iCodeSectionListOffset = 0;

 	}

 void CFontBitmapOld::RestoreComponentsL()

 	{

 	if (iIsInRAM)

 		{

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

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

 			{

 			CodeSectionList()[i].RestoreComponentsL(store);

 			}

 		iCharacterMetricsTable.RestoreL(store);

 		}

 	}

 void CFontBitmapOld::DeleteComponents()

 	{

 	if (iIsInRAM)

 		{

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

 			{

 			CodeSectionList()[i].DeleteComponents();

 			}

 		iCharacterMetricsTable.Delete();

 		}

 	}

 TBitmapCodeSectionOld* CFontBitmapOld::CodeSectionList() const

 	{

 	TInt bcs = TInt(this) + iCodeSectionListOffset;

 	return (TBitmapCodeSectionOld*)bcs;

 	}