// Copyright (c) 2006-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:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#include <e32hal.h>

#include <e32std.h>

#include <e32test.h>

#include <s32mem.h>

#include <bitstd.h>

#include <bitdev.h>

#include <fntstore.h>

#include <fbs.h>

#include <hal.h>

#include <gdi.h>

#include <graphics/fbsdefs.h>

#include "TFont.h"

const TInt KTextBufferLength = 256;

//If you want to do font tests with scaled device - change KScalingFactorX, KScalingFactorY, KScalingOriginPt.

const TInt KScalingFactorX = 1;

const TInt KScalingFactorY = 1;

const TPoint KScalingOriginPt(0, 0);

//--------------------------------------------------------------

CBitmapFont* CFbsFontEx::FontAddress(CFbsFont* aFont)

	{

	return(((CFbsFontEx*)aFont)->Address());

	}

//--------------------------------------------------------------

#ifdef __WINS__

template<class C> XTCallCounter<C>::XTCallCounter(CTGraphicsBase& aTestBase)

	: iTestBase(aTestBase), iVFCallsOutsideFBServ(0)

	{}

template<class C> void XTCallCounter<C>::ExecuteShellcode(TInt aFromFunction)

	{

	const TUint32 KFBServId = 0x10003A16;

	const TUint32 KTBitgdiServerId = 0x10273362;

	TSecureId id = RProcess().SecureId();

	if (id != KFBServId)

		{

		User::LockedInc(iVFCallsOutsideFBServ);

		if (id == KTBitgdiServerId)

			{

			TBuf<128> name;

			XVtableInjector<C>::GetVirtualFunctionName(aFromFunction, name);

			iTestBase.INFO_PRINTF2(_L("Virtual function call to %S from outside FBServ"), &name);

			}

		}

	}

#endif

//--------------------------------------------------------------

CTFont::CTFont(CTestStep* aStep) :

	CTGraphicsBase(aStep),

	iFont(NULL),

	iGc(NULL),

	iDev(NULL)

#ifdef __WINS__

	, iFontCallCounter(*this), iOpenFontCallCounter(*this)

#endif

	{

	}

CTFont::~CTFont()

	{

	delete iGc;

	delete iDev;

	}

void CTFont::ConstructL()

	{

	TRAPD(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor256));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor16MU));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor4K));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor16M));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor64K));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EGray256));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EGray16));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EGray4));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EGray2));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor16));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor16MA));

	if (err == KErrNotSupported)

		TRAP(err,iDev = CFbsScreenDevice::NewL(KNullDesC,EColor16MAP));

	if (err!=KErrNone)

		{

		_LIT(KLog,"Failed to create screen device, last returned error %d");

		INFO_PRINTF2(KLog,err);

		}

	User::LeaveIfError(err);

	iDev->ChangeScreenDevice(NULL);

	iDev->SetAutoUpdate(ETrue);

	iDev->CreateContext(iGc);

	iDev->SetScalingFactor(KScalingOriginPt, KScalingFactorX, KScalingFactorY, 1, 1);

	iGc->Activate(iDev);

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0074

  @SYMDEF             

  @SYMTestCaseDesc Anti-aliased text

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Draws some text in an antialiased manner

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTFont::DoAntiAliasedTextL()

	{

	int typefaces = iDev->NumTypefaces();

	static const TUint32 colour[15] =

		{ 

		0x000000,

		0x555555,

		0x000080,

		0x008000,

		0x008080,

		0x800000,

		0x800080,

		0x808000,

		0x0000ff,

		0x00ff00,

		0x00ffff,

		0xff0000,

		0xff00ff,

		0xffff00,

		0xaaaaaa

		};

	int colour_index = 0;

	for (int i = 0; i < typefaces; i++)

		{

		TTypefaceSupport typeface_support;

		iDev->TypefaceSupport(typeface_support,i);

		if (typeface_support.iIsScalable)

			{

			ResetGc();

			TPoint pos(300,0);

			int vertical_x = 300;

			for (int j = 6; j < 32; j += 2)

				{

				iGc->SetPenColor(colour[colour_index]);

				colour_index = (++colour_index) % 15;

				TFontSpec fs;

				fs.iTypeface = typeface_support.iTypeface;

				fs.iHeight = j;

				fs.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

		 		User::LeaveIfError(GetNearestFontToDesignHeightInPixels(iFont,fs));

				int ascent = iFont->AscentInPixels();

				int descent = iFont->DescentInPixels();

				iGc->UseFont(iFont);

				pos.iY += ascent;

				iGc->DrawText(_L("pack my box with five dozen liquor jugs"),pos);

				pos.iY += descent;

				vertical_x -= ascent;

				TPoint down_pos(vertical_x,0);

				iGc->DrawTextVertical(_L("pack my box with five dozen liquor jugs"),down_pos,FALSE);

				vertical_x -= descent * 2;

				TPoint up_pos(vertical_x,iDev->SizeInPixels().iHeight);

				iGc->DrawTextVertical(_L("pack my box with five dozen liquor jugs"),up_pos,TRUE);

				vertical_x -= ascent;

				iDev->ReleaseFont(iFont);

				iGc->DiscardFont();

				}

			//TheTest.Getch();

			}

		}

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0075

  @SYMDEF             

  @SYMTestCaseDesc tests all fonts

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions tests all fonts (typeface and heights) by writing them to a gc

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTFont::DoAllFontsL()

	{

	TFontSpec fs;

	TInt typefaces = iDev->NumTypefaces();

	TTypefaceSupport info;

	//used below in for loop (line 177)

	TInt topNew=0;

	TInt bottomNew=0;

	TInt top=0;

	TInt bottom=0;

	for (TInt count = 0; count < typefaces; count++)

		{

		iDev->TypefaceSupport(info,count);

		for (TInt index = 0; index < info.iNumHeights; index++)

			{

			TInt height = iDev->FontHeightInPixels(count,index);

			fs.iTypeface = info.iTypeface;

			fs.iHeight = height;

			User::LeaveIfError(GetNearestFontToDesignHeightInPixels(iFont,fs));

			TEST(iFont->HeightInPixels() == height);

			if (height >= 5)

				{

				iGc->UseFont(iFont);

				//Testing the new replaced GetUnderlineMetrics

				//Debug can be used to monitor underline sizes as font chanegs

				iGc->GetUnderlineMetrics(top, bottom);

				TEST( top !=0 && bottom !=0 );

				/*cast the pointer iGc to the base class CGraphicsContext

				should still behave correctly meaning any valid class can 

				GetUnderlineMetrics through CGC as is exported and public.*/

				CGraphicsContext* baseGc = (CGraphicsContext*)iGc;

				baseGc->GetUnderlineMetrics(topNew, bottomNew);

				TEST( top !=0 && bottom !=0 );

				TEST( topNew == top && bottomNew == bottom );

				DisplayAsciiCharSet(info.iTypeface.iName);

				DisplayBoldItalic(info.iTypeface.iName);

				iGc->DiscardFont();

				}

			iDev->ReleaseFont(iFont);

			height = iDev->FontHeightInTwips(count,index);

			fs.iHeight = height;

			User::LeaveIfError(GetNearestFontToDesignHeightInTwips(iFont,fs));

// Commented out test because it fails for true type fonts

//			if (Abs(iFont->FontSpecInTwips().iHeight - height) > 1)

//				User::Panic(_L("Heights don't match"),KErrGeneral);

			iDev->ReleaseFont(iFont);

			}

		}

	}

TInt CTFont::TestFontL(const TFontSpec &aFontSpec)

	{

	const TSize devSize(iDev->SizeInPixels());

	TInt midHgtOffset=devSize.iHeight/2;

	TRect devRect1(0,0,devSize.iWidth,midHgtOffset);

	TRect devRect2(0,midHgtOffset,devSize.iWidth,midHgtOffset*2);

//

	ResetGc();

	TInt loadErr=GetNearestFontToDesignHeightInTwips(iFont,aFontSpec);

	if (loadErr)

		return(loadErr);

	CBufStore *store=CBufStore::NewLC(1024);

	TFontSpec fSpec1=iFont->FontSpecInTwips();

	TEST(fSpec1.iHeight>0);	// If returns zero height will fail on externalize/internalize

	const TInt ascent=iFont->AscentInPixels();

	iGc->UseFont(iFont);

	iDev->ReleaseFont(iFont);

// Useful when watching test code, but too much logging for actual test runs

//	INFO_PRINTF4(_L("Testing, %S hgt=%d/%d"), &aFontSpec.iTypeface.iName,aFontSpec.iHeight,fSpec1.iHeight);

//

	iGc->SetClippingRect(devRect1);

	iGc->DrawText(_L("0123456789abcdefghiABCDEFGHI"),TPoint(0,ascent));

//

	RStoreWriteStream writeStream;

	TStreamId id=writeStream.CreateLC(*store);

	iGc->ExternalizeL(writeStream);

	CleanupStack::PopAndDestroy(&writeStream);

	iGc->DiscardFont();

//

	RStoreReadStream readStream;

	readStream.OpenLC(*store,id);

	iGc->InternalizeL(readStream);

	CleanupStack::PopAndDestroy(&readStream);

	TBool fontUsed=iGc->IsFontUsed();

	if (!iGc->IsFontUsed())

		{

		INFO_PRINTF3(_L("Font externalize/internalize used check failed, %S hgt=%d"), &aFontSpec.iTypeface.iName,aFontSpec.iHeight);

		TEST(EFalse);

		}

	else

		{

		iGc->SetClippingRect(devRect2);

		iGc->DrawText(_L("0123456789abcdefghiABCDEFGHI"),TPoint(0,midHgtOffset+ascent));

		TBool rectCompare=iDev->RectCompare(devRect1,*iDev,devRect2);

		if (!rectCompare)

			{

			INFO_PRINTF3(_L("Font externalize/internalize screen check failed, %S hgt=%d"), &aFontSpec.iTypeface.iName,aFontSpec.iHeight);

			TEST(EFalse);

			}

		}

	CleanupStack::PopAndDestroy(store);

	iGc->CancelClippingRect();

	iGc->DiscardFont();

	return(KErrNone);

	}

void CTFont::FontExternalizeL()

	{

	TFontSpec fsp;

	const TInt typefaceCount=iDev->NumTypefaces();

	for (TInt typeface=0;typeface<typefaceCount;typeface++)

		{

		TTypefaceSupport info;

		iDev->TypefaceSupport(info,typeface);

		fsp.iTypeface = info.iTypeface;

		TInt baseHeight=iDev->FontHeightInTwips(typeface,0);

		_LIT(KTxtNotScalable,"");

		_LIT(KTxtScalable,"Scalable");

		INFO_PRINTF5(_L("Testing, %S min/max=%d/%d %S"), &fsp.iTypeface.iName,info.iMinHeightInTwips,info.iMaxHeightInTwips,info.iIsScalable?&KTxtScalable:&KTxtNotScalable);

		for(TInt hgtIndex=0;hgtIndex<info.iNumHeights;hgtIndex++)

			{	// Test official specced heights

			fsp.iHeight=iDev->FontHeightInTwips(typeface,hgtIndex);

			TEST(TestFontL(fsp)==KErrNone);

			}

		for(fsp.iHeight=0;fsp.iHeight<info.iMaxHeightInTwips*2;fsp.iHeight=(fsp.iHeight+1)*11/10)

			{

			TInt err=TestFontL(fsp);

			if (err!=KErrNone)

				{	// Should not get an error within allowable font size

				TEST(fsp.iHeight>info.iMaxHeightInTwips);	// Over speced max size is ok to get error loading.

				}

			}

		}

	}

void CTFont::DisplayAsciiCharSet(const TDesC& aTypefaceName)

	{

	ResetGc();

	TBuf<KTextBufferLength> textBuffer;

	textBuffer.SetLength(KTextBufferLength);

	for (TInt count = 0; count < KTextBufferLength; count++)

		textBuffer[count] = TText(count);

	TPoint textPos = TPoint(50,iFont->AscentInPixels() + 5);

	iGc->DrawText(aTypefaceName,textPos);

	TInt fontHeight = iFont->HeightInPixels() + 5;

	textPos.iX = 0;

	textPos.iY += fontHeight;

	TInt start = 0;

	TInt screenWidth = iDev->SizeInPixels().iWidth;

	while (start < KTextBufferLength)

		{

		TInt numChars = iFont->TextCount(textBuffer.Mid(start),screenWidth);

		iGc->DrawText(textBuffer.Mid(start,numChars),textPos);

		textPos.iY += fontHeight;

		start += numChars;

		}

	}

void CTFont::DisplayBoldItalic(const TDesC& aTypefaceName)

	{

	ResetGc();

	TBuf<64> textBuffer;

	TInt height = iFont->HeightInPixels();

	CBitmapFont* bmpfon=CFbsFontEx::FontAddress(iFont);

	TInt level=iFont->AscentInPixels();

	iGc->DrawText(aTypefaceName,TPoint(50,level));

	textBuffer=_L("0123456789abcdefghiABCDEFGHI");

	level += height;

	iGc->DrawText(textBuffer,TPoint(0,level));

	iGc->DrawLine(TPoint(iFont->TextWidthInPixels(textBuffer),level-8),TPoint(iFont->TextWidthInPixels(textBuffer),level+2));

	bmpfon->iAlgStyle.SetIsBold(ETrue);

	level += height;

	iGc->DrawText(textBuffer,TPoint(0,level));

	iGc->DrawLine(TPoint(iFont->TextWidthInPixels(textBuffer),level-8),TPoint(iFont->TextWidthInPixels(textBuffer),level+2));

	bmpfon->iAlgStyle.SetIsBold(EFalse);

	bmpfon->iAlgStyle.SetIsItalic(ETrue);

	level += height;

	iGc->DrawText(textBuffer,TPoint(0,level));

	iGc->DrawLine(TPoint(iFont->TextWidthInPixels(textBuffer),level-8),TPoint(iFont->TextWidthInPixels(textBuffer),level+2));

	bmpfon->iAlgStyle.SetIsBold(ETrue);

	level += height;

	iGc->DrawText(textBuffer,TPoint(0,level));

	iGc->DrawLine(TPoint(iFont->TextWidthInPixels(textBuffer),level-8),TPoint(iFont->TextWidthInPixels(textBuffer),level+2));

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0076

  @SYMDEF             

  @SYMTestCaseDesc Text formatting

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Tests drawing of justified/clipped/underlined text to a gc 

  @SYMTestExpectedResults Test should perform graphics operations succesfully. 

*/

void CTFont::DoTextFormatsL()

	{

	ResetGc();

	TFontSpec fsp;

	fsp.iTypeface.iName=_L("Swiss");

	fsp.iHeight=200;

	User::LeaveIfError(GetNearestFontToDesignHeightInTwips(iFont,fsp));

	iGc->UseFont(iFont);

	Box();

	//TheTest.Getch();

	Justification();

	//TheTest.Getch();

	Clipping();

	//TheTest.Getch();

	Underline();

	//TheTest.Getch();

	iGc->DiscardFont();

	iDev->ReleaseFont(iFont);

	}

void CTFont::Box()

	{

	iGc->SetPenSize(TSize(0,0));

	iGc->SetBrushColor(KRgbWhite);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->Clear();

	iGc->DrawText(_L("Font test code:"),TPoint(20,20));

	iGc->DrawText(_L("Normal text printing, followed by posi"),TPoint(20,40));

	iGc->DrawText(_L("tionless printing (halfway thro' posi-tionless)."));

	iGc->DrawText(_L("Box text (left aligned)"),TRect(20,50,320,70),14,CGraphicsContext::ELeft);

	iGc->DrawText(_L("Box text (left aligned with margin)"),TRect(20,70,320,90),14,CGraphicsContext::ELeft,50);

	iGc->DrawText(_L("Box text (centred)"),TRect(20,90,320,110),14,CGraphicsContext::ECenter);

	iGc->DrawText(_L("Box text (right aligned)"),TRect(20,110,320,130),14,CGraphicsContext::ERight);

	iGc->DrawText(_L("Box text (right aligned with margin)"),TRect(20,130,320,150),14,CGraphicsContext::ERight,30);

	iGc->DrawText(_L("(Boxes drawn afterwards)"),TPoint(20,165));

	iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iGc->DrawRect(TRect(20,50,320,70));

	iGc->DrawRect(TRect(20,70,320,90));

	iGc->DrawRect(TRect(20,90,320,110));

	iGc->DrawRect(TRect(20,110,320,130));

	iGc->SetBrushColor(TRgb(128,128,128));

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->DrawText(_L("Box text (left aligned)"),TRect(320,50,620,70),14,CGraphicsContext::ELeft);

	iGc->DrawText(_L("Box text (left aligned with margin)"),TRect(320,70,620,90),14,CGraphicsContext::ELeft,50);

	iGc->DrawText(_L("Box text (centred)"),TRect(320,90,620,110),14,CGraphicsContext::ECenter);

	iGc->DrawText(_L("Box text (right aligned)"),TRect(320,110,620,130),14,CGraphicsContext::ERight);

	iGc->DrawText(_L("Box text (right aligned with margin)"),TRect(320,130,620,150),14,CGraphicsContext::ERight,30);

	iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iGc->DrawRect(TRect(320,50,620,70));

	iGc->DrawRect(TRect(320,70,620,90));

	iGc->DrawRect(TRect(320,90,620,110));

	iGc->DrawRect(TRect(320,110,620,130));

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TInt width=iFont->TextWidthInPixels(_L("Box text followed by positionless text."));

	iGc->DrawText(_L("Box text"),TRect(20,150,620,170),14,width);

	iGc->DrawText(_L(" followed by positionless text."));

	iGc->DrawText(_L("Box text"),TRect(20,170,620,190),14,width,CGraphicsContext::ELeft,20);

	iGc->DrawText(_L(" followed by positionless text."));

	iGc->DrawText(_L("Box text"),TRect(20,190,620,210),14,width,CGraphicsContext::ECenter);

	iGc->DrawText(_L(" followed by positionless text."));

	iGc->DrawText(_L("Box text"),TRect(20,210,620,230),14,width,CGraphicsContext::ERight,20);

	iGc->DrawText(_L(" followed by positionless text."));

	iGc->DrawText(_L(""),TRect(20,230,620,250),14,width);

	iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	iGc->DrawRect(TRect(20,150,620,170));

	iGc->DrawRect(TRect(20,170,620,190));

	iGc->DrawRect(TRect(20,190,620,210));

	iGc->DrawRect(TRect(20,210,620,230));

	}

void CTFont::Underline()

	{

	ResetGc();

	iGc->SetUnderlineStyle(EUnderlineOn);

	iGc->SetStrikethroughStyle(EStrikethroughOn);