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