/*

* Copyright (c) 2002-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 "TGraphicsContext.h"

#include <e32std.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

#endif

_LIT(KTestFontName, "Non Functional Test Font");

// Utility functions to show contents of test data using test.Printf

extern void PrintTestData (const TDesC& aTitle , const TDesC16& aDataBuffer);

extern void PrintTestData(const TDesC& aTitle, const TText16* aDataBuffer, const TInt aSize);

//

//

// CLineArray

//

//

CLineArray::CLineArray() : iArrayIsEnabled(ETrue), iArray(0)

	{

	iPrev = iNext = this;

	}

void CLineArray::Null()

	{

	if (iNext == this && iArray)

		{

		iArray->Close();

		delete iArray;

		}

	iArray = 0;

	iPrev->iNext = iNext;

	iNext->iPrev = iPrev;

	iNext = iPrev = this;

	}

CLineArray::~CLineArray()

	{

	Null();

	}

void CLineArray::ConstructL(TInt aGranularity)

	{

	CLineArray::Null();

	iArray = new (ELeave) RArray<TTestGCDisplayLine>(aGranularity);

	}

void CLineArray::Copy(const CLineArray& aOther)

	{

	CLineArray::Null();

	iNext = &aOther;

	iPrev = aOther.iPrev;

	iPrev->iNext = this;

	aOther.iPrev = this;

	iArray = aOther.iArray;

	iArrayIsEnabled = aOther.iArrayIsEnabled;

	}

void CLineArray::ResetLineArray()

	{

	iArray->Reset();

	}

const TTestGCDisplayLine& CLineArray::Line(TInt aIndex)

	{

	return (*iArray)[aIndex];

	}

const TTestGCDisplayLine* CLineArray::Find(const TDesC& aText)

	{

	TInt count = LinesPresent();

	for (TInt i = 0; i != count; ++i)

		{		

		const TTestGCDisplayLine& line = Line(i);

		if (line.iLineData.Find(aText) != KErrNotFound)

			return &line;

		}

	return 0;

	}

void CLineArray::AddLineL(TTestGCDisplayLine& aLine)

	{

	if (iArrayIsEnabled)

		User::LeaveIfError(iArray->Append(aLine));

	}

TInt CLineArray::LinesPresent()

	{

	return iArray->Count();

	}

//

//

// CTestGraphicsDevice

//

//

CTestGraphicsDevice* CTestGraphicsDevice::NewL(TSize aSizeInPixels, RWsSession* aWsSession)

	{

	CTestGraphicsDevice* r = aWsSession?

		new (ELeave) CTestGraphicsDevice(aSizeInPixels, aWsSession)

		: new (ELeave) CTestGraphicsDevice(aSizeInPixels);

	r->iLineArray.ConstructL(4);

	if (aWsSession && KErrNone != r->Construct())

		{

		delete r;

		return 0;

		}

	return r;

	}

CTestGraphicsDevice::CTestGraphicsDevice(TSize aSizeInPixels, RWsSession* aWsSession)

	: CWsScreenDevice(*aWsSession)

	{

	Set(aSizeInPixels);

	}

CTestGraphicsDevice::CTestGraphicsDevice(TSize aSizeInPixels)

	{

	Set(aSizeInPixels);

	}

void CTestGraphicsDevice::Set(TSize aSizeInPixels)

	{

	iSize = aSizeInPixels;

	iHorizontalTwipsToPixels = 40;

	iVerticalTwipsToPixels = 40;

	iPalette.SetEntry(0, KRgbBlack);

	iPalette.SetEntry(1, KRgbWhite);

	iPalette.SetEntry(2, KRgbMagenta);

	iPalette.SetEntry(3, KRgbCyan);

	}

void CTestGraphicsDevice::SetHorizontalTwipsToPixels(TInt aTwipsToPixels)

	{

	iHorizontalTwipsToPixels = aTwipsToPixels;

	}

void CTestGraphicsDevice::SetVerticalTwipsToPixels(TInt aTwipsToPixels)

	{

	iVerticalTwipsToPixels = aTwipsToPixels;

	}

TDisplayMode CTestGraphicsDevice::DisplayMode() const

	{

	return EColor16M;

	}

TSize CTestGraphicsDevice::SizeInPixels() const

	{

	return iSize;

	}

TSize CTestGraphicsDevice::SizeInTwips() const

	{

	return TSize(iSize.iWidth * iHorizontalTwipsToPixels,

		iSize.iHeight * iVerticalTwipsToPixels);

	}

TInt CTestGraphicsDevice::CreateContext(CWindowGc*& aGC)

	{

	CTestGraphicsContext* r = new CTestGraphicsContext(this);

	if (!r)

		return KErrNoMemory;

	// only contruct if it is a fully-fledged Window Server thing

	if (iBuffer)

		r->Construct();

	aGC = r;

	return KErrNone;

	}

TInt CTestGraphicsDevice::CreateContext(CGraphicsContext*& aGC)

	{

	CWindowGc* p;

	TInt r = CreateContext(p);

	aGC = p;

	return r;

	}

TInt CTestGraphicsDevice::NumTypefaces() const

	{

	return 1;

	}

void CTestGraphicsDevice::TypefaceSupport(TTypefaceSupport& aTypefaceSupport, TInt aTypefaceIndex) const

	{

	// The only font we have at the moment is 10 pixels * 12 pixels for every character

	__ASSERT_ALWAYS(aTypefaceIndex == 0,

		CTestGraphicsContext::Panic(CTestGraphicsContext::ETypefaceIndexOutOfRange));

	aTypefaceSupport.iIsScalable = EFalse;

	aTypefaceSupport.iMaxHeightInTwips = iVerticalTwipsToPixels * 12;

	aTypefaceSupport.iMinHeightInTwips = iVerticalTwipsToPixels * 10;

	aTypefaceSupport.iNumHeights = 1;

	aTypefaceSupport.iTypeface.iName = KTestFontName;

	aTypefaceSupport.iTypeface.SetIsProportional(ETrue); // a bit of a lie

	aTypefaceSupport.iTypeface.SetIsSerif(EFalse);

	aTypefaceSupport.iTypeface.SetIsSymbol(EFalse);

	}

TInt CTestGraphicsDevice::FontHeightInTwips(TInt aTypefaceIndex, TInt aHeightIndex) const

	{

	// The only font we have at the moment is 10 pixels * 12 pixels for every character

	__ASSERT_ALWAYS(aTypefaceIndex == 0,

		CTestGraphicsContext::Panic(CTestGraphicsContext::ETypefaceIndexOutOfRange));

	return iVerticalTwipsToPixels * FontHeightInPixels(aTypefaceIndex, aHeightIndex);

	}

void CTestGraphicsDevice::PaletteAttributes(TBool& aModifiable, TInt& aNumEntries) const

	{

	aModifiable = ETrue;

	aNumEntries = 4;

	}

void CTestGraphicsDevice::SetPalette(CPalette* aPalette)

	{

	for (TInt i = 0; i != CTestPalette::KNumEntries; ++i)

		{

		TRgb col = aPalette->GetEntry(i);

		iPalette.SetEntry(i, col);

		}

	}

TInt CTestGraphicsDevice::GetPalette(CPalette*& aPalette) const

	{

	aPalette = const_cast<CTestPalette*>(&iPalette);

	return KErrNone;

	}

void CTestGraphicsDevice::GetPixel(TRgb& aColor, const TPoint&) const

	{

	aColor = KRgbWhite;

	}

void CTestGraphicsDevice::GetScanLine(TDes8&, const TPoint&, TInt, TDisplayMode) const

	{

	__ASSERT_DEBUG(0, CTestGraphicsContext::Panic(CTestGraphicsContext::EUnimplemented));

	}

TInt CTestGraphicsDevice::AddFile(const TDesC&, TInt&)

	{

	return KErrNotSupported;

	}

void CTestGraphicsDevice::RemoveFile(TInt)

	{

	}

TInt CTestGraphicsDevice::GetNearestFontInPixels(CFont*& aFont, const TFontSpec&)

	{

	CTestFont* font = new CTestFont();

	if (!font)

		return KErrNoMemory;

	aFont = font;

	return KErrNone;

	}

TInt CTestGraphicsDevice::FontHeightInPixels(TInt, TInt) const

	{

	return 12;

	}

TInt CTestGraphicsDevice::HorizontalTwipsToPixels(TInt aTwips) const

	{

	return aTwips / iHorizontalTwipsToPixels;

	}

TInt CTestGraphicsDevice::VerticalTwipsToPixels(TInt aTwips) const

	{

	return aTwips / iVerticalTwipsToPixels;

	}

TInt CTestGraphicsDevice::HorizontalPixelsToTwips(TInt aPixels) const

	{

	return aPixels * iHorizontalTwipsToPixels;

	}

TInt CTestGraphicsDevice::VerticalPixelsToTwips(TInt aPixels) const

	{

	return aPixels * iVerticalTwipsToPixels;

	}

TInt CTestGraphicsDevice::GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec)

	{

	TFontSpec fontSpec = aFontSpec;

	fontSpec.iHeight = VerticalTwipsToPixels(fontSpec.iHeight);

	return GetNearestFontInPixels(aFont, fontSpec);

	}

void CTestGraphicsDevice::ReleaseFont(CFont* aFont)

	{

	__ASSERT_ALWAYS(aFont->TypeUid() == TUid::Uid(12345),

		CTestGraphicsContext::Panic(CTestGraphicsContext::EUnknownFont));

	delete static_cast<CTestFont*>(aFont);

	}

void CTestGraphicsDevice::AddRectToDrawnArea(const TRect& aRect, TBool aCondition)

	{

	// check if the drawing is on testing area

	if (!(iTestingArea.IsEmpty()) &&  	// if testing area has been set

		!iHasDrawnOnTestingArea)		// and nothing hasn't been drawn on it so far

		iHasDrawnOnTestingArea = iTestingArea.Intersects(aRect);

	if (iDrawnArea.IsEmpty())

		iDrawnArea = aRect;

	else

		iDrawnArea.BoundingRect(aRect);

	// only one condition at the moment

	if (aCondition)

		{

		if (iAreaDrawnWithCondition.IsEmpty())

			iAreaDrawnWithCondition = aRect;

		else

			iAreaDrawnWithCondition.BoundingRect(aRect);

		}

	}

void CTestGraphicsDevice::SetTestingArea(TRect& aTestingArea)

	{

	iTestingArea = aTestingArea;

	}

void CTestGraphicsDevice::AddTestingArea(TRect& moreTestingArea)

	{

	if (iTestingArea.IsEmpty())

		iTestingArea = moreTestingArea;

	else

		iTestingArea.BoundingRect(moreTestingArea);

	}

//

//

// CTestGraphicsContext

//

//

void CTestGraphicsContext::Panic(TInt aReason)

	{

	User::Panic(_L("CTestGC"), aReason);

	}

CTestGraphicsContext::CTestGraphicsContext(CTestGraphicsDevice* aGd)

	: CWindowGc(aGd), iGd(aGd), iDrawMode(EDrawModePEN), iPenSize(1,1)

	{

	iLineArray.Copy(aGd->LineArray());

	}

TInt CTestGraphicsContext::Construct()

	{

	return CWindowGc::Construct();

	}

void CTestGraphicsContext::AddRectToDrawnArea(const TRect& aRect)

	{

	TRect drawnRect = aRect;

	drawnRect.Grow(iPenSize);

	iGd->AddRectToDrawnArea(drawnRect,

		iDrawMode == EDrawModeXOR || iDrawMode == EDrawModeNOTSCREEN);

	}

void CTestGraphicsContext::AddPointToDrawnArea(const TPoint& aPoint)

	{

	AddRectToDrawnArea(TRect(aPoint, iPenSize));

	}

CGraphicsDevice* CTestGraphicsContext::Device() const

	{

	return iGd;

	}

void CTestGraphicsContext::SetOrigin(const TPoint& aPos)

	{

	iOrigin = aPos;

	}

void CTestGraphicsContext::SetDrawMode(TDrawMode aDrawingMode)

	{

	iDrawMode = aDrawingMode;

	}

void CTestGraphicsContext::SetClippingRect(const TRect& /*aRect*/)

	{

	}

void CTestGraphicsContext::CancelClippingRect()

	{

	}

TInt CTestGraphicsContext::SetClippingRegion(const TRegion& /*aRegion*/)

	{

	return KErrNone;

	}

void CTestGraphicsContext::CancelClippingRegion()

	{

	}

void CTestGraphicsContext::Reset()

	{

	iDrawMode = EDrawModePEN;

	iFont = 0;

	iPenSize.iWidth = 1;

	iPenSize.iHeight = 1;

	}

void CTestGraphicsContext::UseFont(const CFont* aFont)

	{

	iFont = aFont;

	}

void CTestGraphicsContext::DiscardFont()

	{

	iFont = 0;

	}

void CTestGraphicsContext::SetUnderlineStyle(TFontUnderline /*UnderlineStyle*/)

	{

	}

void CTestGraphicsContext::SetStrikethroughStyle(TFontStrikethrough /*aStrikethroughStyle*/)

	{

	}

void CTestGraphicsContext::SetWordJustification(TInt /*aExcessWidth*/,TInt /*aNumGaps*/)

	{

	}

void CTestGraphicsContext::SetCharJustification(TInt /*aExcessWidth*/,TInt /*aNumChars*/)

	{

	}

void CTestGraphicsContext::SetPenColor(const TRgb& aColor)

	{

	CPalette* palette;

	iGd->GetPalette(palette);

	iPenColorIndex = palette->NearestIndex(aColor);

	}

void CTestGraphicsContext::SetPenStyle(TPenStyle /*aPenStyle*/)

	{

	}

void CTestGraphicsContext::SetPenSize(const TSize& aSize)

	{

	iPenSize = aSize;

	}

void CTestGraphicsContext::SetBrushColor(const TRgb& /*aColor*/)

	{

	}

void CTestGraphicsContext::SetBrushStyle(TBrushStyle /*aBrushStyle*/)

	{

	}

void CTestGraphicsContext::SetBrushOrigin(const TPoint& /*aOrigin*/)

	{

	}

void CTestGraphicsContext::UseBrushPattern(const CFbsBitmap* /*aBitmap*/)

	{

	}

void CTestGraphicsContext::DiscardBrushPattern()

	{

	}

void CTestGraphicsContext::MoveTo(const TPoint& aPoint)

	{

	iCurrentPos = iOrigin + aPoint;

	}

void CTestGraphicsContext::MoveBy(const TPoint& aVector)

	{

	iCurrentPos += aVector;

	}

void CTestGraphicsContext::Plot(const TPoint& aPoint)

	{

	iCurrentPos = iOrigin + aPoint;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawArc(const TRect& aRect,const TPoint& /*aStart*/,const TPoint& aEnd)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	AddRectToDrawnArea(r);

	iCurrentPos = iOrigin + aEnd;

	}

void CTestGraphicsContext::DrawLine(const TPoint& aPoint1,const TPoint& aPoint2)

	{

	AddPointToDrawnArea(iOrigin + aPoint1);

	iCurrentPos = iOrigin + aPoint2;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawLineTo(const TPoint& aPoint)

	{

	AddPointToDrawnArea(iCurrentPos);

	iCurrentPos = iOrigin + aPoint;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawLineBy(const TPoint& aVector)

	{

	AddPointToDrawnArea(iCurrentPos);

	iCurrentPos += aVector;

	AddPointToDrawnArea(iCurrentPos);

	}

void CTestGraphicsContext::DrawPolyLine(const CArrayFix<TPoint>* aPointList)

	{

	TInt num = aPointList->Count();

	while (num--)

		{

		iCurrentPos = iOrigin + (*aPointList)[num - 1];

		AddPointToDrawnArea(iCurrentPos);

		}

	}

void CTestGraphicsContext::DrawPolyLine(const TPoint* aPointList,TInt aNumPoints)

	{

	while (aNumPoints--)

		{

		iCurrentPos = iOrigin + aPointList[aNumPoints - 1];

		AddPointToDrawnArea(iCurrentPos);

		}

	}

void CTestGraphicsContext::DrawPie(const TRect& aRect,

	const TPoint& /*aStart*/, const TPoint& aEnd)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	AddRectToDrawnArea(r);

	iCurrentPos = iOrigin + aEnd;

	}

void CTestGraphicsContext::DrawEllipse(const TRect& aRect)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	AddRectToDrawnArea(r);

	}

void CTestGraphicsContext::DrawRect(const TRect& aRect)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	AddRectToDrawnArea(r);

	}

void CTestGraphicsContext::DrawRoundRect(const TRect& aRect,const TSize& aCornerSize)

	{

	TRect r = aRect;

	r.Move(iOrigin);

	r.Grow(aCornerSize);

	AddRectToDrawnArea(r);

	}

TInt CTestGraphicsContext::DrawPolygon(const CArrayFix<TPoint>* aPointList,TFillRule /*aFillRule*/)

	{

	TInt num = aPointList->Count();

	while (num--)

		{

		iCurrentPos = iOrigin + (*aPointList)[num - 1];

		AddPointToDrawnArea(iCurrentPos);

		}

	return KErrNone;

	}

TInt CTestGraphicsContext::DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule /*aFillRule*/)

	{

	while (aNumPoints--)

		{

		iCurrentPos = iOrigin + aPointList[aNumPoints - 1];

		AddPointToDrawnArea(iCurrentPos);

		}

	return KErrNone;

	}

void CTestGraphicsContext::DrawBitmap(const TPoint& /*aTopLeft*/,const CFbsBitmap* /*aSource*/)

	{

	}

void CTestGraphicsContext::DrawBitmap(const TRect& /*aDestRect*/,const CFbsBitmap* /*aSource*/)

	{

	}

void CTestGraphicsContext::DrawBitmap(const TRect& /*aDestRect*/,const CFbsBitmap* /*aSource*/,const TRect& /*aSourceRect*/)

	{

	}

void CTestGraphicsContext::DrawText(const TDesC& aText, const TPoint& aPosition)

	{

#ifdef PRINT_DRAWTEXT_LINES

	_LIT(KDrawTextTitle, "Text being drawn");

		PrintTestData(KDrawTextTitle, aText);

#endif /* PRINT_DRAWTEXT_LINES */

	TTestGCDisplayLine thisLine;

	thisLine.Set(aPosition, aText);

	iLineArray.AddLineL(thisLine);

	}

void CTestGraphicsContext::DrawText(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,

	TTextAlign /*aAlignment*/, TInt aLeftMargin)

	{

	TPoint pos(aBox.iBr.iX + aLeftMargin, aBox.iTl.iY + aBaselineOffset);

	pos += iOrigin;

	DrawText(aText, pos);

	}

void CTestGraphicsContext::DrawText(const TDesC& aText,TTextParameters* aParam, const TPoint& aPosition)

	{

#ifdef PRINT_DRAWTEXT_LINES

	_LIT(KDrawTextTitle, "Text being drawn");

		PrintTestData(KDrawTextTitle, aText);

#endif /* PRINT_DRAWTEXT_LINES */

	//Avoid crash by ASSERT in BitGdi DrawText function

	__ASSERT_ALWAYS(aParam->iStart < aParam->iEnd,

		CTestGraphicsContext::Panic(CTestGraphicsContext::EErrorParameter));

	TTestGCDisplayLine thisLine;

	TPtrC actualText = aText.Mid(aParam->iStart,aParam->iEnd - aParam->iStart + 1);

	thisLine.Set(aPosition, actualText);

	iLineArray.AddLineL(thisLine);

	}

void CTestGraphicsContext::DrawText(const TDesC& aText,TTextParameters* aParam,const TRect& aBox,TInt aBaselineOffset,

	TTextAlign /*aAlignment*/, TInt aLeftMargin)

	{

	TPoint pos(aBox.iBr.iX + aLeftMargin, aBox.iTl.iY + aBaselineOffset);

	pos += iOrigin;

	DrawText(aText,aParam, pos);

	}

TInt CTestGraphicsContext::APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput)

	{

	if (aUid == KDrawTextInContextUid)

		{

		TDrawTextInContextInternal* contextParam = (TDrawTextInContextInternal*)aInput;

		DrawText(contextParam->iText, &contextParam->iParam, contextParam->iPosition);

		return KErrNone;

		}

	else if (aUid == KDrawBoxTextInContextUid)

		{

		TDrawTextInContextInternal* contextParam = (TDrawTextInContextInternal*)aInput;

		DrawText(contextParam->iText,&contextParam->iParam,contextParam->iBox,contextParam->iBaselineOffset,contextParam->iAlign,contextParam->iMargin);

		return KErrNone;

		}

	// Future cases may be placed here later

	else

		return CWindowGc::APIExtension(aUid, aOutput, aInput);

	}

void CTestGraphicsContext::Clear()

	{

	}

void CTestGraphicsContext::Clear(const TRect& /*aRect*/)

	{

	}

void CTestGraphicsContext::CopyRect(const TPoint& /*aOffset*/, const TRect& /*aRect*/)

	{

	}

void CTestGraphicsContext::BitBlt(const TPoint& /*aPoint*/, const CFbsBitmap* /*aBitmap*/)

	{

	}

void CTestGraphicsContext::BitBlt(const TPoint& /*aPoint*/, const CFbsBitmap* /*aBitmap*/,

	const TRect& /*aRect*/)

	{

	}

void CTestGraphicsContext::BitBltMasked(const TPoint& /*aPoint*/, const CFbsBitmap* /*aBitmap*/,

	const TRect& /*aSourceRect*/, const CFbsBitmap* /*aMaskBitmap*/, TBool /*aInvertMask*/)

	{

	}

void CTestGraphicsContext::SetFaded(TBool)

	{

	}

void CTestGraphicsContext::SetFadingParameters(TUint8,TUint8)

	{

	}

//

//

// CTestFont

//

//

inline TBool IsSurrogate(TText a) { return 0xD800 == (a & 0xF800); }

inline TBool IsHighSurrogate(TText a) { return 0xD800 == (a & 0xFC00); }

inline TBool IsLowSurrogate(TText a) { return 0xDC00 == (a & 0xFC00); }

inline TChar PairSurrogates(TText aHigh, TText aLow)

	{

	return ((aHigh - 0xd7f7) << 10) + aLow;

	}

TUid CTestFont::DoTypeUid() const

	{

	return TUid::Uid(12345);

	}

TInt CTestFont::DoHeightInPixels() const

	{

	return 12;

	}

TInt CTestFont::DoAscentInPixels() const

	{

	return 10;

	}

struct TSpecialSizes

	{

	TInt iCharacter;

	TInt iWidth;

	};

static const TSpecialSizes KSpecialSizes[] =

	{

	{ CTestFont::KThreePerEmSpace, 3 },

	{ CTestFont::KThinSpace, 2 },

	{ CTestFont::KHairSpace, 1 },

	{ CTestFont::KZeroWidthSpace, 0 },

	{ CTestFont::KZeroWidthNoBreakSpace, 0 },

	};

TInt CTestFont::DoCharWidthInPixels(TChar aChar) const

	{

	TInt cn = aChar;

	// non-characters 0x??FFFE and 0x??FFFF

	if ((cn & 0xFFFE) == 0xFFFE)

		return 0;

	// Find character in the special sizes table

	TInt first = 0;

	TInt last = sizeof(KSpecialSizes)/sizeof(KSpecialSizes[0]);

	while (first != last)

		{

		TInt c = static_cast<TInt>(aChar);

		TInt mid = (first + last) >> 1;

		if (c < KSpecialSizes[mid].iCharacter)

			last = mid;

		else if (KSpecialSizes[mid].iCharacter < c)

			first = mid + 1;

		else

			return KSpecialSizes[mid].iWidth;

		}

	return 10;

	}

TInt CTestFont::DoTextCount(const TDesC& aText, TInt aWidthInPixels,

	TInt& aExcessWidthInPixels) const

	{

	const TText* p = &aText[0];

	const TText* pEnd = p + aText.Length();

	TInt total = 0;

	TInt prevSurrogate = 0;

	TInt charactersThatFit = 0;

	while (p != pEnd)

		{

		TChar c = *p;

		if (IsSurrogate(*p))

			{

			c = 0xFFFF;

			if (IsHighSurrogate(*p))

				prevSurrogate = *p;

			else if (prevSurrogate != 0)

				{

				c = PairSurrogates(static_cast<TText>(prevSurrogate), *p);

				prevSurrogate = 0;

				}

			}

		else

			prevSurrogate = 0;

		total += CharWidthInPixels(c);

		if (total <= aWidthInPixels)

			++charactersThatFit;

		++p;

		}

	aExcessWidthInPixels = total - aWidthInPixels;

	return charactersThatFit;

	}

TInt CTestFont::DoTextWidthInPixels(const TDesC& aText) const

	{

	TInt excess;

	TextCount(aText, 0, excess);

	return excess;

	}

TInt CTestFont::DoBaselineOffsetInPixels() const

	{

	return 10;

	}

TInt CTestFont::DoTextCount(const TDesC& aText,TInt aWidthInPixels) const

	{

	TInt excess;

	return TextCount(aText, aWidthInPixels, excess);

	}

TInt CTestFont::DoMaxCharWidthInPixels() const

	{

	return 10;

	}

TInt CTestFont::DoMaxNormalCharWidthInPixels() const

	{

	return 10;

	}

TFontSpec CTestFont::DoFontSpecInTwips() const

	{

	return TFontSpec(KTestFontName, 12);

	}

CFont::TCharacterDataAvailability 

CTestFont::DoGetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics,

	const TUint8*& aBitmap, TSize& aBitmapSize) const

	{

	TInt width;

	switch (aCode)

		{

	case 0x001B:

		// ESC character should cause this fault; no character data available.

		return CFont::ENoCharacterData;

	case 'W':

		// We want 'W' to have side-bearings

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		width = aMetrics.Width();

		aMetrics.SetHorizBearingX(-1);

		aMetrics.SetWidth(width + 2);

		return CFont::ECharacterWidthOnly ;

	case '/':

		// We want / to have a left side-bearing

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		width = aMetrics.Width();

		aMetrics.SetHorizBearingX(-1);

		aMetrics.SetWidth(width + 1);

		return CFont::ECharacterWidthOnly ;

	case 'D':

		// We want 'D' to have a left side-bearing only

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		aMetrics.SetHorizBearingX(-1);

		return CFont::ECharacterWidthOnly ;

	case KTav:

		// We want Hebrew Tav to have a +ve left side-bearing

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		aMetrics.SetHorizBearingX(1);

		return CFont::ECharacterWidthOnly ;

	case KFullWidthSolidus:

		// We want fw/ to have a right side-bearing

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		width = aMetrics.Width();

		aMetrics.SetWidth(width + 1);

		return CFont::ECharacterWidthOnly ;

	case KArabicWaw:

		// Arabic Waw-- has massive left side-bearing

		CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		width = aMetrics.Width();

		aMetrics.SetHorizBearingX(-5);

		aMetrics.SetWidth(width + 5);

		return CFont::ECharacterWidthOnly ;

	default:

		return CFont::DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);

		}

	}