// Copyright (c) 1997-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 "PDRBODY.H"

#include "PDRSTD.H"

TPdrResource::TPdrResource():

	iId(0),

	iString()

	{

	}

void TPdrResource::InternalizeL(RReadStream& aStream)

	{

	iId = aStream.ReadUint8L();

	aStream >> iString;

	}

CPdrTranslation::CPdrTranslation():

	iFrom(0),

	iTo(NULL)

	{

	__DECLARE_NAME(_S("CPdrTranslation"));

	}

CPdrTranslation::~CPdrTranslation()

	{

	delete iTo;

	}

void CPdrTranslation::InternalizeL(RReadStream& aStream)

	{

	iFrom = aStream.ReadUint16L();

	iTo=HBufC8::NewL(aStream,KMaxCommandStringMaxLength);

	}

CPdrTranslates::CPdrTranslates():

	iStreamId(KNullStreamId),

	iNumTranslations(0),

	iTranslationList(NULL)

	{

	__DECLARE_NAME(_S("CPdrTranslates"));

	}

void CPdrTranslates::InternalizeL(RReadStream& aStream)

	{

	TInt size=aStream.ReadInt32L();

	iTranslationList = new(ELeave) CPdrTranslation*[size];

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

		{

		iTranslationList[i]=new(ELeave) CPdrTranslation;

		iNumTranslations++;

		iTranslationList[i]->InternalizeL(aStream);

		}

	}

CPdrTranslates::~CPdrTranslates()

	{

	for (; iNumTranslations>0; iNumTranslations--)

		delete iTranslationList[iNumTranslations-1];

	delete[] iTranslationList;

	}

HBufC8* CPdrTranslates::TranslateStringL(const TDesC& aString) const 

	{

	CPdrTranslation** pEnd=iTranslationList+iNumTranslations;

	TInt length1=aString.Length(),length2=length1;

	if (iNumTranslations)

		{

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

			{

			for (CPdrTranslation** p=iTranslationList; p<pEnd; p++)

				if (aString[i]==(*p)->iFrom)

					length2+=(*p)->iTo->Des().Length()-1;

			}

		}

	HBufC8* string2=HBufC8::NewL(length2);

	string2->Des().Copy(aString);	

	if (iNumTranslations)

		{

		CleanupStack::PushL(string2);	

		HBufC8* string1=HBufC8::NewL(length1);

		string1->Des().Copy(aString);	

		TInt j=0;

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

			{

			for (CPdrTranslation** p=iTranslationList; p<pEnd; p++)

				{

				if (aString[i]==(*p)->iFrom)

					{

					if ((*p)->iTo->Des().Length()==1)

						{

						string2->Des()[j]=(*p)->iTo->Des()[0];

						}

					else

						{

						string2->Des().SetLength(j);

						string2->Des().Append((*p)->iTo->Des());

						j+=(*p)->iTo->Des().Length()-1;

						if ((i+1)<length1)

							{

							string2->Des().SetLength(j+1);

							string2->Des().Append(string1->Des().Mid(i+1));

							}

						}

					}

				}

			j++;

			}

		delete string1;

		CleanupStack::Pop();

		}

	return string2;

	}

CWidthsCodeSection::CWidthsCodeSection():

	iNumWidths(0),

	iWidthList(NULL)

	{

	__DECLARE_NAME(_S("CWidthsCodeSection"));

	}

void CWidthsCodeSection::InternalizeL(RReadStream& aStream)

	{

	iCodeSection.iStart = aStream.ReadUint16L();

	iCodeSection.iEnd = aStream.ReadUint16L();

	iNumWidths = aStream.ReadInt32L();

	iWidthList = new(ELeave) TUint16[iNumWidths];

	TUint16* pEnd = iWidthList+iNumWidths;

	for (TUint16* p=iWidthList; p<pEnd; p++)

		*p = aStream.ReadUint16L();

	}

CWidthsCodeSection::~CWidthsCodeSection()

	{

	delete[] iWidthList;

	iNumWidths=0;

	iWidthList=NULL;

	}

CFontInfo::CFontInfo(TStreamId aStreamId):

	iStreamId(aStreamId),

	iAscentInPixels(0),

	iMaxCharWidthInPixels(0),

	iMaxNormalCharWidthInPixels(0),

	iNumCodeSections(0),

	iCodeSectionList(NULL)

	{

	__DECLARE_NAME(_S("CFontInfo"));

	}

void CFontInfo::InternalizeL(RReadStream &aStream)

	{

	iAscentInPixels = aStream.ReadUint16L();

	iMaxCharWidthInPixels = aStream.ReadUint16L();

	iMaxNormalCharWidthInPixels = aStream.ReadUint16L();

	TInt size = aStream.ReadInt32L();

	iCodeSectionList = new(ELeave) CWidthsCodeSection*[size];

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

		{

		iCodeSectionList[i]=new(ELeave) CWidthsCodeSection;

		iNumCodeSections++;

		iCodeSectionList[i]->InternalizeL(aStream);

		}

	}

CFontInfo::~CFontInfo()

	{

	for (; iNumCodeSections>0; iNumCodeSections--)

		delete iCodeSectionList[iNumCodeSections-1];

	delete[] iCodeSectionList;

	}

TInt CFontInfo::CharWidthInPixels(TChar aChar) const

	{

	TInt width=0,code=TUint(aChar);

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

		{

		CWidthsCodeSection* p=iCodeSectionList[i];

		if ((code>=p->iCodeSection.iStart) && (code<=p->iCodeSection.iEnd))

			{

			if (p->iNumWidths==1)

				width=p->iWidthList[0];

			else 

				width = *((p->iWidthList)+(code-p->iCodeSection.iStart));

			}

		}

	return width;

	}

TInt CFontInfo::NumCodeSections() const

	{

	return iNumCodeSections;

	}

TCodeSection CFontInfo::CodeSection(TInt anIndex) const

	{

	return iCodeSectionList[anIndex]->iCodeSection;

	}

TPdrStyle::TPdrStyle():

	iIsAvailable(EFalse),

	iFontInfoStreamId(KNullStreamId)

	{

	}

void TPdrStyle::InternalizeL(RReadStream &aStream)

	{

	iIsAvailable = aStream.ReadUint8L();

	aStream >> iFontInfoStreamId;

	}	

TPdrFontHeight::TPdrFontHeight():

	iCommandString(),

	iHeightInTwips(0),

	iWidthScale(1),

	iStyle() 

	{

	}

void TPdrFontHeight::InternalizeL(RReadStream& aStream)

	{

	aStream >> iCommandString;

	iHeightInTwips = aStream.ReadInt32L();

	iWidthScale = aStream.ReadInt32L();

	for (TInt style=EStyleNormal; style<(EStyleBoldItalic+1); style++)

		iStyle[style].InternalizeL(aStream);

	}

TPdrScalableFontHeight::TPdrScalableFontHeight():

	iCommandString(),

	iHeightMinInTwips(0),

	iHeightMaxInTwips(0),

	iHeightDeltaInTwips(0),

	iStyle() 

	{

	}

void TPdrScalableFontHeight::InternalizeL(RReadStream& aStream)

	{

	aStream >> iCommandString;

	iHeightMinInTwips = aStream.ReadInt32L();

	iHeightMaxInTwips = aStream.ReadInt32L();

	iHeightDeltaInTwips = aStream.ReadInt32L();

	for (TInt style=EStyleNormal; style<(EStyleBoldItalic+1); style++)

		iStyle[style].InternalizeL(aStream);

	}

CTypefaceFonts::CTypefaceFonts():

	iTypeface(),

	iNumFontHeights(0),

	iFontHeightList(NULL),

	iScalableFontHeight(NULL),

	iTranslates()

	{

	__DECLARE_NAME(_S("CTypefaceFonts"));

	}

void CTypefaceFonts::InternalizeL(RReadStream& aStream)

	{

	iTypeface.InternalizeL(aStream);

	TInt isscalable = aStream.ReadInt8L();

 	if (!isscalable)

		{

		iNumFontHeights = aStream.ReadInt32L();

		iFontHeightList = new(ELeave) TPdrFontHeight[iNumFontHeights];

		TPdrFontHeight *pStart=iFontHeightList, *pEnd=pStart+iNumFontHeights;

		for (TPdrFontHeight *p=pStart; p<pEnd; p++)

			p->InternalizeL(aStream);

		}

	else

		{

		iScalableFontHeight = new(ELeave) TPdrScalableFontHeight;

		iScalableFontHeight->InternalizeL(aStream);

		}

	aStream >> iTranslates;

	}

CTypefaceFonts::~CTypefaceFonts()

	{

	if (!IsScalable())

		{

		iNumFontHeights=0;

		delete[] iFontHeightList;

		iFontHeightList=NULL;

		}

	else

		{

		delete iScalableFontHeight;

		iScalableFontHeight=NULL;

		}

	}

TInt CTypefaceFonts::IsScalable() const

	{

	return !iNumFontHeights;

	}

TInt CTypefaceFonts::NumFontHeights() const

	{

	TInt num;

	if (!IsScalable())

		num = iNumFontHeights;

	else

		num = ((iScalableFontHeight->iHeightMaxInTwips-iScalableFontHeight->iHeightMinInTwips)/iScalableFontHeight->iHeightDeltaInTwips) + 1;

	return num;

	}

TInt CTypefaceFonts::FontHeightInTwips(TInt aHeightIndex) const

	{

	TInt height=0;

	__ASSERT_DEBUG((aHeightIndex>=0) && (aHeightIndex<NumFontHeights()),Panic(EPdrHeightIndexOutOfRange));

	if (!IsScalable())

		height = iFontHeightList[aHeightIndex].iHeightInTwips;

	else

		height = iScalableFontHeight->iHeightMinInTwips + (iScalableFontHeight->iHeightDeltaInTwips*aHeightIndex);

	return height;

	}

TInt CTypefaceFonts::FontInfoHeightInTwips(TInt aHeightIndex) const

	{

	TInt height=0;

	__ASSERT_DEBUG((aHeightIndex>=0) && (aHeightIndex<NumFontHeights()),Panic(EPdrHeightIndexOutOfRange));

	if (!IsScalable())

		height = iFontHeightList[aHeightIndex].iHeightInTwips/iFontHeightList[aHeightIndex].iWidthScale;

	else

		height = KScalableWidthTableHeightInTwips;

	return height;

	}

void CTypefaceFonts::CommandString(TDes8& aDes,TInt aHeightIndex) const

	{

	__ASSERT_DEBUG((aHeightIndex>=0) && (aHeightIndex<NumFontHeights()),Panic(EPdrHeightIndexOutOfRange));

	if (!IsScalable())

		aDes=iFontHeightList[aHeightIndex].iCommandString;

	else

		{

		TInt heightinpoints=FontHeightInTwips(aHeightIndex)/KTwipsPerPoint;

		aDes.Format(iScalableFontHeight->iCommandString,heightinpoints);

		}

	}

TPdrStyle* CTypefaceFonts::Style(TInt aHeightIndex,TFontStyle& aFontStyle) const

	{

	TPdrStyle* style=NULL;

	TStyleIndex index=StyleIndex(aFontStyle);

	__ASSERT_DEBUG((aHeightIndex>=0) && (aHeightIndex<NumFontHeights()),Panic(EPdrHeightIndexOutOfRange));

	if (!IsScalable())

		style = iFontHeightList[aHeightIndex].iStyle+index;

	else

		style = iScalableFontHeight->iStyle+index;

	return style;

	}

TTypeface CTypefaceFonts::Typeface()

	{

	return iTypeface;

	}

TStyleIndex CTypefaceFonts::StyleIndex(TFontStyle& aFontStyle) const

	{

	TStyleIndex index;

	if (aFontStyle.StrokeWeight()==EStrokeWeightNormal)

		{

		if (aFontStyle.Posture()==EPostureUpright)

			index=EStyleNormal;

		else

			index=EStyleItalic;

		}

	else

		{

		if (aFontStyle.Posture()==EPostureUpright)

			index=EStyleBold;

		else

			index=EStyleBoldItalic;

		}

	return index;

	}