// 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 <pdrstore.h>
#include <banddev.h>
#include "PDRBODY.H"
#include "PDRSTD.H"
#include "pdrtext.h"

EXPORT_C CPdrResources::CPdrResources():
	iNumResources(0),
	iResourceList(NULL)
	{
	__DECLARE_NAME(_S("CPdrResources"));
	}

EXPORT_C void CPdrResources::RestoreL(CStreamStore& aStore, TStreamId aStreamId)
	{
	RStoreReadStream stream;
	stream.OpenLC(aStore, aStreamId);
	iNumResources = stream.ReadInt32L();
	iResourceList = new(ELeave) TPdrResource[iNumResources];
	for (TInt i = 0; i < iNumResources; i++)
		iResourceList[i].InternalizeL(stream);
	CleanupStack::PopAndDestroy();
	}

EXPORT_C CPdrResources::~CPdrResources()
	{
	delete[] iResourceList;
	iResourceList = NULL;
	iNumResources = 0;
	}

EXPORT_C TPtrC8 CPdrResources::ResourceString(TInt anId) const
	{
	TPtrC8 ptr;
	TPdrResource* pEnd = iResourceList + iNumResources;
	TPdrResource* p ;
	for( p = iResourceList; (p < pEnd) && (p->iId != anId); p++)
		{
		}
	if (p < pEnd)
		ptr.Set(p->iString);
	return ptr;
	}

CInfoFont::CInfoFont(TInt aBaselineOffsetInPixels, const TFontSpec& aFontSpecInTwips, TInt aFontInfoHeightInTwips, TInt aHeightInPixels, CPdrTranslates* aTranslates, const TDesC8& aCommandString, CPdrDevice* aPdrDevice):
	CFont(),
	iCommandString(aCommandString),	
	iBaselineOffsetInPixels(aBaselineOffsetInPixels),
	iFontSpecInTwips(aFontSpecInTwips),
	iFontInfoHeightInTwips(aFontInfoHeightInTwips),
	iHeightInPixels(aHeightInPixels),
	iFontInfo(NULL),
	iTranslates(aTranslates),
	iPdrDevice(aPdrDevice),
	iRealFont(NULL)
	{
	CreateBandedFontIfRequired();
	}

CInfoFont::~CInfoFont()
	{
	if (iRealFont)
		if (iPdrDevice->iControl)
			((CPdrControl*)(iPdrDevice->iControl))->BandedDevice()->ReleaseFont(iRealFont);
	}

void CInfoFont::CreateBandedFontIfRequired()
	{
	if (!iRealFont)
		{
		if (iPdrDevice->iControl)
			{
			if (((CPdrControl*)(iPdrDevice->iControl))->BandedDevice())
				((CPdrControl*)(iPdrDevice->iControl))->BandedDevice()->GetNearestFontToDesignHeightInTwips(iRealFont, iFontSpecInTwips);
			}
		}
	}

EXPORT_C TUid CInfoFont::DoTypeUid() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return TUid::Uid(KCInfoFontUidVal);
	}

EXPORT_C TInt CInfoFont::DoHeightInPixels() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return iHeightInPixels;
	}

EXPORT_C TInt CInfoFont::DoAscentInPixels() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return Height(iFontInfo->iAscentInPixels);
	}

EXPORT_C TInt CInfoFont::DoCharWidthInPixels(TChar aChar) const
	{
	TInt width;
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	if (RepertoireContains(aChar))
		{
		width = iFontInfo->CharWidthInPixels(TUint(aChar));
		width = Width(width);
		}
	else
		{
		if (iRealFont)
			width = iRealFont->CharWidthInPixels(TUint(aChar));
		else
			width = 0;
		}
	return width;
	}

EXPORT_C TInt CInfoFont::DoTextWidthInPixels(const TDesC &aText) const
	{
	TMeasureTextOutput output;
	TInt advance_width = MeasureText(aText,NULL,&output);
	return Max(advance_width,output.iBounds.Width());
	}

EXPORT_C TInt CInfoFont::DoBaselineOffsetInPixels() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return iBaselineOffsetInPixels;
	}

EXPORT_C TInt CInfoFont::DoTextCount(const TDesC &aText, TInt aWidthInPixels) const
	{
	TInt count = 0;
	TInt width = 0;
	TInt length = aText.Length();
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	for (count = 0; (count < length) && ((width += MeasureText(aText.Mid(count, 1))) < aWidthInPixels); )
		{
		count++;
		}
	return count;
	}

EXPORT_C TInt CInfoFont::DoTextCount(const TDesC &aText, TInt aWidthInPixels, TInt &aExcessWidthInPixels) const
	{
	TInt count = TextCount(aText, aWidthInPixels);
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	aExcessWidthInPixels = aWidthInPixels - MeasureText(aText.Left(count));
	return count;
	}

EXPORT_C TInt CInfoFont::DoMaxCharWidthInPixels() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	TInt width = Width(iFontInfo->iMaxCharWidthInPixels);
	if (iRealFont)
		return Max(iRealFont->MaxCharWidthInPixels(),width);
	return width;
	}

EXPORT_C TInt CInfoFont::DoMaxNormalCharWidthInPixels() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	TInt width = Width(iFontInfo->iMaxNormalCharWidthInPixels);
	if (iRealFont)
		return Max(iRealFont->MaxNormalCharWidthInPixels(),width);
	return width;
	}

EXPORT_C TFontSpec CInfoFont::DoFontSpecInTwips() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return iFontSpecInTwips;	
	}

EXPORT_C HBufC8* CInfoFont::TranslateStringL(const TDesC& aString) const  
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return iTranslates->TranslateStringL(aString);
	}

EXPORT_C TPtrC8 CInfoFont::CommandString() const
	{
	TPtrC8 ptr;
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	ptr.Set(iCommandString);
	return ptr;
	}

EXPORT_C TBool CInfoFont::RepertoireContains(TChar aChar) const
	{
	CFontInfo* fontInfo = FontInfo();
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	for (TInt i = 0; i < fontInfo->NumCodeSections(); i++)
		{
		if (((TInt)(TUint)aChar >= fontInfo->CodeSection(i).iStart) && ((TInt)(TUint)aChar<= fontInfo->CodeSection(i).iEnd))
			return ETrue;
		}
	return EFalse;
	}

EXPORT_C TBool CInfoFont::AllCharsInFontRepertoire(const TDesC& aString, TInt& aFirstCharNotInRepertoire, TInt& aLength) const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	for (aFirstCharNotInRepertoire = 0; aFirstCharNotInRepertoire < aString.Length(); aFirstCharNotInRepertoire++)
		if (!(RepertoireContains(aString[aFirstCharNotInRepertoire])))
			{
			if (aFirstCharNotInRepertoire == 0)
				{	// Work out length
				for (aLength = aFirstCharNotInRepertoire; aLength < aString.Length(); aLength++)
					if ((RepertoireContains(aString[aLength])))
						break;
				}
			return EFalse;
			}
	return ETrue;
	}

CFont* CInfoFont::RealFont() const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return iRealFont;
	}

TInt CInfoFont::Width(TInt aNum) const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return (aNum * iFontSpecInTwips.iHeight + (iFontInfoHeightInTwips / 2)) / iFontInfoHeightInTwips;
	}

TInt CInfoFont::Height(TInt aNum) const
	{
	CONST_CAST(CInfoFont*,this)->CreateBandedFontIfRequired();
	return (aNum * iFontSpecInTwips.iHeight + (iFontInfoHeightInTwips / 2)) / iFontInfoHeightInTwips;
	}

EXPORT_C void TTypefaceFontsEntry::InternalizeL(RReadStream& aStream)
	{
	aStream >> iStreamId;
	iNotInPortrait = aStream.ReadUint8L();
	iNotInLandscape = aStream.ReadUint8L();
	}

EXPORT_C CPdrModelInfo::CPdrModelInfo():
	iFlags(0),
	iKPixelWidthInTwips(0),
	iKPixelHeightInTwips(0),
	iPortraitOffsetInPixels(),
	iLandscapeOffsetInPixels(),
//	iMinMarginsInPixels(),
	iDisplayMode(EGray2),
	iNumTypefaceFonts(0),
	iTypefaceFontsEntryList(NULL),
	iResourcesStreamId(KNullStreamId),
	iSpareStreamId(KNullStreamId)
	{
	__DECLARE_NAME(_S("CPdrModelInfo"));
	}

EXPORT_C CPdrModelInfo::~CPdrModelInfo()
	{
	delete[] iTypefaceFontsEntryList;
	}

EXPORT_C void CPdrModelInfo::InternalizeL(RReadStream& aStream)
	{
	TInt pdrtranversion = aStream.ReadInt32L();
	if (pdrtranversion < KPdrtranVersion)
		User::Leave(KErrNotSupported);
	iFlags = aStream.ReadInt32L();
	iKPixelWidthInTwips = aStream.ReadInt32L();
	iKPixelHeightInTwips = aStream.ReadInt32L();
	iPortraitOffsetInPixels.iX = aStream.ReadInt32L();
	iPortraitOffsetInPixels.iY = aStream.ReadInt32L();
	iLandscapeOffsetInPixels.iX = aStream.ReadInt32L();
	iLandscapeOffsetInPixels.iY = aStream.ReadInt32L();
	iMinMarginsInPixels.InternalizeL(aStream);
	iDisplayMode = (TDisplayMode)aStream.ReadInt32L();
	iNumTypefaceFonts = aStream.ReadInt32L();
	iTypefaceFontsEntryList = new(ELeave) TTypefaceFontsEntry[iNumTypefaceFonts];
	TTypefaceFontsEntry* pEnd = iTypefaceFontsEntryList+iNumTypefaceFonts;
	for(TTypefaceFontsEntry* p = iTypefaceFontsEntryList; p < pEnd; p++)
		p->InternalizeL(aStream);
	aStream >> iResourcesStreamId; 
	aStream >> iSpareStreamId; 
	}

CPdrTypefaceStore::CPdrTypefaceStore(CStreamStore& aStore, TInt aKPixelHeightInTwips, CPdrDevice* aPdrDevice):
	iPdrDevice(aPdrDevice),
	iStore(&aStore),
	iKPixelHeightInTwips(aKPixelHeightInTwips)
	{
	}

void CPdrTypefaceStore::ConstructL(TInt aNumTypefaceFonts, TTypefaceFontsEntry* aTypefaceFontsEntryList, TPageSpec::TPageOrientation aPageOrientation)
	{
	CTypefaceStore::ConstructL();
	iTranslatesList = new(ELeave) CArrayPtrFlat<CPdrTranslates>(8);
	iTypefaceFontsList = new(ELeave) CArrayPtrFlat<CTypefaceFonts>(8);
	iPortraitTypefaceFontsList = new(ELeave) CArrayPtrFlat<CTypefaceFonts>(8);
	iLandscapeTypefaceFontsList = new(ELeave) CArrayPtrFlat<CTypefaceFonts>(8);
	iFontInfoList = new(ELeave) CArrayPtrFlat<CFontInfo>(8);
	for (TInt i = 0; i < aNumTypefaceFonts; i++)
		{
		CTypefaceFonts* typefacefonts = new(ELeave) CTypefaceFonts;
		CleanupStack::PushL(typefacefonts);
		RStoreReadStream stream;
		stream.OpenLC(*iStore, aTypefaceFontsEntryList[i].iStreamId);
		typefacefonts->InternalizeL(stream);
		CleanupStack::PopAndDestroy();
		iTypefaceFontsList->AppendL(typefacefonts);
		CleanupStack::Pop();
		typefacefonts->iTranslates=TranslatesL(typefacefonts->iTranslates.AsId());
		if (!aTypefaceFontsEntryList[i].iNotInPortrait)
			iPortraitTypefaceFontsList->AppendL(typefacefonts);
		if (!aTypefaceFontsEntryList[i].iNotInLandscape)
			iLandscapeTypefaceFontsList->AppendL(typefacefonts);
		}
	SetPageOrientation(aPageOrientation);
	}

EXPORT_C CPdrTypefaceStore* CPdrTypefaceStore::NewL(CStreamStore& aStore, TInt aNumTypefacesFonts, TTypefaceFontsEntry* aTypefaceFontsEntryList, TPageSpec::TPageOrientation aPageOrientation, TInt aKPixelHeightInTwips, CPdrDevice* aPdrDevice)
	{
	CPdrTypefaceStore* typefacestore = new(ELeave) CPdrTypefaceStore(aStore, aKPixelHeightInTwips, aPdrDevice);
	CleanupStack::PushL(typefacestore);
	typefacestore->ConstructL(aNumTypefacesFonts, aTypefaceFontsEntryList, aPageOrientation);
	CleanupStack::Pop();
	return typefacestore;
	}

EXPORT_C CPdrTypefaceStore::~CPdrTypefaceStore()
	{
	if (iTranslatesList)
		iTranslatesList->ResetAndDestroy();
	delete iTranslatesList;
	if (iTypefaceFontsList)
		iTypefaceFontsList->ResetAndDestroy();
	delete iTypefaceFontsList;
	delete iPortraitTypefaceFontsList;
	delete iLandscapeTypefaceFontsList;
	if (iFontInfoList)
		iFontInfoList->ResetAndDestroy();
	delete iFontInfoList;
	}

/**
@internalTechnology
*/
EXPORT_C TInt CPdrTypefaceStore::GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec)
	{
	return GetNearestFontToDesignHeightInTwips(aFont, aFontSpec);
	}

/**
@internalTechnology
*/
EXPORT_C TInt CPdrTypefaceStore::GetNearestFontToDesignHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec)
	{
	aFont = NULL;
	const TInt count = iCurrentTypefaceFontsList->Count();
	if (count)
		{
		TInt index = 0;
		TTypeface typeface = aFontSpec.iTypeface;
		for (index = 0; (index < count) && typeface.iName.CompareF((*iCurrentTypefaceFontsList)[index]->Typeface().iName); index++)
			{ // tries matching typeface name
			}
		if (index == count)
			{
			if (!typeface.IsSymbol())
				{
				for (index = 0; (index < count) && (((*iCurrentTypefaceFontsList)[index]->Typeface().IsSymbol()) ||
													(typeface.IsProportional() != (*iCurrentTypefaceFontsList)[index]->Typeface().IsProportional()) || 
													(typeface.IsSerif() != (*iCurrentTypefaceFontsList)[index]->Typeface().IsSerif())); index++)
					{ // tries matching typeface flags
					}
				if (index == count)
					for (index = 0; (index < count) && (((*iCurrentTypefaceFontsList)[index]->Typeface().IsSymbol()) ||
														(typeface.IsProportional() != (*iCurrentTypefaceFontsList)[index]->Typeface().IsProportional())); index++)
						{ // tries matching typeface flag
						}
				if (index == count)
					for (index = 0; (index < count) && ((*iCurrentTypefaceFontsList)[index]->Typeface().IsSymbol()); index++)
						{ // tries matching typeface flag
						}
				}
			else
				{
				for (index = 0; (index < count) && (!(*iCurrentTypefaceFontsList)[index]->Typeface().IsSymbol()); index++)
					{ // finds first symbol typeface
					}
				}
			}
		if (index == count)
			index = 0;
		CTypefaceFonts* typefacefonts = (*iCurrentTypefaceFontsList)[index];
		if (typefacefonts->NumFontHeights())
			{
			TFontSpec fontspec(aFontSpec);
			fontspec.iTypeface = typefacefonts->Typeface();
			TInt i = GetNearestFontHeightIndex(index, aFontSpec.iHeight);
			fontspec.iHeight = typefacefonts->FontHeightInTwips(i);
			if (fontspec.iFontStyle.PrintPosition() != EPrintPosNormal)
				{
				i = GetNearestFontHeightIndex(index, SuperSubHeight(fontspec.iHeight, fontspec.iFontStyle.PrintPosition()));
				}
			fontspec.iFontStyle = GetNearestFontStyle(index, i, fontspec.iFontStyle);
			TInt heightintwips = typefacefonts->FontHeightInTwips(i);
			TInt height = VerticalTwipsToPixels(heightintwips);
			if (IsFontLoaded(aFont, fontspec, height))
				return KErrNone;
			TInt baselineoffset = BaselineOffset(VerticalTwipsToPixels(fontspec.iHeight), fontspec.iFontStyle.PrintPosition());
			TInt fontinfoheight = ((fontspec.iHeight * typefacefonts->FontInfoHeightInTwips(i) + (heightintwips / 2))) / heightintwips;
			CPdrTranslates* translates = typefacefonts->iTranslates;
			TCommandString commandstring;
			typefacefonts->CommandString(commandstring, i);
			TStreamId fontinfostreamid = typefacefonts->Style(i, fontspec.iFontStyle)->iFontInfoStreamId;
			TRAPD(ret, aFont = NewFontL(baselineoffset, fontspec, fontinfoheight, height, translates, commandstring, fontinfostreamid));
			return ret;
			}
		}
	return KErrNotFound;
	}

/**
@internalTechnology
*/
EXPORT_C TInt CPdrTypefaceStore::GetNearestFontToMaxHeightInTwips(CFont*& /*aFont*/, const TFontSpec& /*aFontSpec*/, TInt /* aMaxHeight */)
	{
	return KErrNotSupported;
	}

EXPORT_C TInt CPdrTypefaceStore::NumTypefaces() const
	{
	return iCurrentTypefaceFontsList->Count();
	}

EXPORT_C TInt CPdrTypefaceStore::FontHeightInTwips(TInt aTypefaceIndex, TInt aHeightIndex) const
	{
	TInt height = 0;
	__ASSERT_DEBUG((aTypefaceIndex >= 0) && (aTypefaceIndex < NumTypefaces()), Panic(EPdrHeightIndexOutOfRange));
	CTypefaceFonts* typefacefonts = (*iCurrentTypefaceFontsList)[aTypefaceIndex];
	height = typefacefonts->FontHeightInTwips(aHeightIndex);
	return height;
	}

EXPORT_C void CPdrTypefaceStore::TypefaceSupport(TTypefaceSupport &aTypefaceSupport, TInt aTypefaceIndex) const
	{
	__ASSERT_DEBUG((aTypefaceIndex >= 0) && (aTypefaceIndex < NumTypefaces()), Panic(EPdrHeightIndexOutOfRange));
	CTypefaceFonts* typefacefonts = (*iCurrentTypefaceFontsList)[aTypefaceIndex];
	aTypefaceSupport.iTypeface = typefacefonts->Typeface();
	aTypefaceSupport.iIsScalable = typefacefonts->IsScalable();
	aTypefaceSupport.iNumHeights = typefacefonts->NumFontHeights();
	aTypefaceSupport.iMinHeightInTwips = FontHeightInTwips(aTypefaceIndex, 0);  // Font heights must be in ascending order
	aTypefaceSupport.iMaxHeightInTwips = FontHeightInTwips(aTypefaceIndex, aTypefaceSupport.iNumHeights - 1);
	}

EXPORT_C void CPdrTypefaceStore::SetPageOrientation(TPageSpec::TPageOrientation aPageOrientation)
	{
	if (aPageOrientation == TPageSpec::EPortrait)
		iCurrentTypefaceFontsList = iPortraitTypefaceFontsList;
	else
		iCurrentTypefaceFontsList = iLandscapeTypefaceFontsList;
	}

CFontInfo* CPdrTypefaceStore::FontInfoL(TStreamId aStreamId) const
	{
	CFontInfo* fontinfo;
	TInt i;
	const TInt count = iFontInfoList->Count();
	for (i = 0; (i < count) && ((*iFontInfoList)[i]->iStreamId != aStreamId); i++)
		{  // Searches for FontInfo with same Id
		}
	if (i < count)  // Found
		fontinfo = (*iFontInfoList)[i];
	else			// Not found
		{
		RStoreReadStream stream;
		fontinfo = new(ELeave) CFontInfo(aStreamId);
		CleanupStack::PushL(fontinfo);
		stream.OpenLC(*iStore, aStreamId);
		fontinfo->InternalizeL(stream);
		CleanupStack::PopAndDestroy();
		iFontInfoList->AppendL(fontinfo);
		CleanupStack::Pop();
		}
	return fontinfo;
	}

CPdrTranslates* CPdrTypefaceStore::TranslatesL(TStreamId aStreamId) const
	{
	CPdrTranslates* translates;
	TInt i;
	const TInt count = iTranslatesList->Count();
	for (i = 0; (i < count) && ((*iTranslatesList)[i]->iStreamId != aStreamId); i++)
		{  // Searches for Translate with same Id
		}
	if (i < count)  // Found
		translates = (*iTranslatesList)[i];
	else			// Not found
		{
		RStoreReadStream stream;
		translates = new(ELeave) CPdrTranslates;
		CleanupStack::PushL(translates);
		translates->iStreamId = aStreamId;
		stream.OpenLC(*iStore, aStreamId);
		translates->InternalizeL(stream);
		CleanupStack::PopAndDestroy();
		iTranslatesList->AppendL(translates);
		CleanupStack::Pop();
		}
	return translates;
	}

TInt CPdrTypefaceStore::GetNearestFontHeightIndex(TInt aTypefaceIndex, TInt aHeightInTwips) const
	{
	CTypefaceFonts* typefacefonts = (*iCurrentTypefaceFontsList)[aTypefaceIndex];
	TInt i;
	TInt size = typefacefonts->NumFontHeights();
	for (i = size - 1; (i > 0) && (aHeightInTwips < typefacefonts->FontHeightInTwips(i)); i--)
		{  //  Finds fontheight less than or equal to fontspec height
		}
	return i;
	}

TFontStyle CPdrTypefaceStore::GetNearestFontStyle(TInt aTypefaceIndex, TInt aHeightIndex, const TFontStyle& aFontStyle) const
	{
	TFontStyle fontstyle(aFontStyle);
	CTypefaceFonts* typefacefonts = (*iCurrentTypefaceFontsList)[aTypefaceIndex];
	while (!typefacefonts->Style(aHeightIndex, fontstyle)->iIsAvailable)
		{  //  finds first available style
		if ((fontstyle.StrokeWeight() == EStrokeWeightBold) && (fontstyle.Posture() == EPostureItalic))
			fontstyle.SetPosture(EPostureUpright);
		else
			{
			fontstyle.SetPosture(EPostureUpright);
			fontstyle.SetStrokeWeight(EStrokeWeightNormal);
			}
		}
	return fontstyle;
	}

TBool CPdrTypefaceStore::IsFontLoaded(CFont*& aFont, const TFontSpec& aFontSpecInTwips, TInt aHeightInPixels) const
/**
@see CFbsTypefaceStore::IsFontLoaded
@see CFontStore::IsFontLoaded
*/
	{
	TInt i = 0;
	const TInt count = iFontAccess->Count();
	for (; i < count &&
			!(aHeightInPixels  == (*iFontAccess)[i].iFont->HeightInPixels() &&
			  aFontSpecInTwips == (*iFontAccess)[i].iFont->FontSpecInTwips()); i++)
		{
		}
	if (i < count)
		{
		aFont = (*iFontAccess)[i].iFont;
		(*iFontAccess)[i].iAccessCount++;
		return ETrue;
		}
	return EFalse;
	}

CInfoFont* CPdrTypefaceStore::NewFontL(TInt aBaselineOffsetInPixels, const TFontSpec& aFontSpecInTwips, TInt aFontInfoHeightInTwips, TInt aHeightInPixels, CPdrTranslates* aTranslates, const TDesC8& aCommandString, TStreamId aFontInfoStreamId)
	{
	CInfoFont* infofont = new(ELeave) CInfoFont(aBaselineOffsetInPixels, aFontSpecInTwips, aFontInfoHeightInTwips, aHeightInPixels, aTranslates, aCommandString, iPdrDevice);
	CleanupStack::PushL(infofont);
	AddFontL(infofont);
	CleanupStack::Pop();
	TRAPD(ret, infofont->iFontInfo = FontInfoL(aFontInfoStreamId));
	if (ret != KErrNone)
		{
		ReleaseFont(infofont);
		User::Leave(ret);
		}
	return infofont;
	}

TInt CPdrTypefaceStore::VerticalTwipsToPixels(TInt aTwipsHeight) const
	{
	return (1000 * aTwipsHeight + (iKPixelHeightInTwips / 2)) / iKPixelHeightInTwips;
	}