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