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

// This test is designed to run in environment with monotype font support.

// To set up environment launch ityperast.cmd  from epoc32\winscw\, and 

// then follow instruction on the screen.

// 

//

#include "tglyphimagecache.h"

#include <graphics/directgdiengine.h>

#include <e32base.h>

#include <VG/openvg.h>

// The size of the target in pixels to use for these tests

const TSize KGlyphCacheWindowSize(400, 400);

enum TFontParam

	{

	ENormal, 

	EUnderline = 0x1, 

	EStrikeThrough = 0x2,

	EBold = 0x4,

	EUnderlineBold = 0x5, 

	EItalic = 0x8,

	EItalicStrikeThrough = 0xa,

	};

class TFontType

	{

public:

	TInt iFontSize;

	TFontParam iFontParam;

	}; 

LOCAL_C void CleanCache(TAny* aPtr)

	{

	MFontGlyphImageStorage* glyphImageStorage = reinterpret_cast<MFontGlyphImageStorage*> (aPtr);

	glyphImageStorage->CleanGlyphImageCache();

	}

CTGlyphImageCache::CTGlyphImageCache()

	{

	SetTestStepName(KTGlyphImageCacheStep);

	}

CTGlyphImageCache::~CTGlyphImageCache()

	{

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0001

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test requests Glyph Image elements from storage according their Glyph Key.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Create Font Image Storage. In the cycle request aGlyph Image entry for a particular Glyph 

	code and a font ID. 

	Delete Glyph Storage.

@SYMTestExpectedResults

	GlyphImage function must succeed; foreground, shadow and outlined images (if applicable) must be created

*/

void CTGlyphImageCache::TestRetrieveEntryL(MFontGlyphImageStorage* aGlyphStorage, TGlyphBitmapType aGlyphType)

	{

	if(!aGlyphStorage)

		return;	

	_LIT(KTestName, "GlyphCache_RetrieveEntry"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TSize size(20, 30);

	TInt bufferLength = size.iWidth * size.iHeight;

	TUint8* buffer = (TUint8*)User::AllocL(bufferLength);

	CleanupStack::PushL(buffer);

	if(aGlyphType == EMonochromeGlyphBitmap)

		{//to make decoding mechanizm work properly we need to fill the buffer

		Mem::Fill(buffer, bufferLength, 0x1);

		}

	TInt fontListId[] = 

		{

		1, 5, 3, 5

		};

	TInt numFont = sizeof(fontListId) / sizeof(fontListId[0]);

	TUint charCodeList[] =

		{

		1, 2, 3, 2, 3,

		};

	TInt numGlyphCode = sizeof(charCodeList) / sizeof(charCodeList[0]);

	for(TInt jj = 0; jj < numFont; jj++)

		{

		TInt fontId = fontListId[jj];

		for(TInt ii = 0; ii < numGlyphCode; ii++)

			{

			TChar glyphCode = TChar(charCodeList[ii]);

			VGImage foregroundImg = VG_INVALID_HANDLE;

			VGImage shadowImg = VG_INVALID_HANDLE;

			VGImage outlineImg = VG_INVALID_HANDLE;

			TBool res = aGlyphStorage->GlyphImage(fontId, glyphCode, aGlyphType, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

			TESTNOERROR(res);

			if(res != KErrNone)

				{

				User::Leave(res); 

				}

			else

				{

				TEST(foregroundImg);

				if(aGlyphType == EFourColourBlendGlyphBitmap)

					{

					TEST(shadowImg);

					TEST(outlineImg);

					}

				}	

			}

		}

	CleanupStack::PopAndDestroy(buffer);

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Drawing monochrome, anti-aliased and four colour fonts with different styles  

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Text is output with different effects (strikethrough, underline) and orientation 

	(horizontal, vertical up, vertical down) and at different sizes and positions.

	Clip region is also specified.

@SYMTestExpectedResults

	Test and reference images must match

*/

void CTGlyphImageCache::TestDrawGlyphL(MFontGlyphImageStorage* aGlyphStorage, TGlyphBitmapType aGlyphBitmapType, DrawTextDirection aDirection, DrawTextAdjustment aDrawAdjustment, TBool aClipText)

	{	

	_LIT(KTestNameTemplate, "DrawGlyph%S_Dir%d_Clip%d_Adjust%d"); 

	TBuf<128> testName;

	_LIT(KTextOutput, "Hello world! Hello world! Hello world! Hello world! Hello world! Hello world!");

	switch(aGlyphBitmapType)

		{

	case EMonochromeGlyphBitmap:

		_LIT(KMonochromeName, "Monochrome");

		testName.Format(KTestNameTemplate, &KMonochromeName, aDirection, aClipText, aDrawAdjustment);

		break;

	case EAntiAliasedGlyphBitmap:

		_LIT(KAntiAliasedName, "AntiAliased");

		testName.Format(KTestNameTemplate, &KAntiAliasedName, aDirection, aClipText, aDrawAdjustment);

		break;

	case EFourColourBlendGlyphBitmap:

		_LIT(KFourColourName, "FourColour");

		testName.Format(KTestNameTemplate, &KFourColourName, aDirection, aClipText, aDrawAdjustment);

		break;

	default: 

		User::Leave(KErrNotSupported);

		break;	

		}

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(testName);

		}

	ResetGc();

	_LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

	const TFontType fontType[] =

		{

		18, EStrikeThrough, 48, EUnderline, 16, EItalic, 78, EItalicStrikeThrough,

		18, EStrikeThrough, 48, EUnderlineBold, 16, ENormal, 78, EStrikeThrough, 78, EBold, 

		};

	TPoint pt(5, 5);

	TInt *coord = & (pt.iY);

	TSize size = iGdiTarget->SizeInPixels();

	TRect rect = size;

	rect.Shrink(20, 5);

	RRegion region(rect);

	TRect rect1;

	if(aDirection == EDrawTextHorizontal)

		{

		rect1 = TRect(size.iWidth / 2 - 40, 40, size.iWidth / 2 + 40, size.iHeight - 40);

		}

	else

		{

		rect1 = TRect(20, size.iHeight / 2 - 40, size.iWidth - 20, size.iHeight / 2 + 40);

		}	

	region.SubRect(rect1);

	if(aDirection == EDrawTextVerticalUp || aDirection == EDrawTextVerticalDown)

		{

		if(aDirection == EDrawTextVerticalUp)

			{

			pt.iY = size.iHeight - 5;

			}

		coord = &(pt.iX);

		}

	TInt arraySize = sizeof(fontType) / sizeof(fontType[0]);

	for(TInt ii = 0; ii < arraySize; ii++)

		{

		CFont *font = NULL;

		TFontSpec fspec(KTestFontTypefaceName, fontType[ii].iFontSize);

		fspec.iFontStyle.SetBitmapType(aGlyphBitmapType);

		iGc->Reset();

		if(aClipText)

			{

			iGc->SetClippingRegion(region);

			}

		if(aGlyphBitmapType == EFourColourBlendGlyphBitmap)

			{

			fspec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

			fspec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

			fspec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

			TRgb shadowColor = TRgb(0, 0, 255);

			iGc->SetTextShadowColor(shadowColor);

			TEST(shadowColor == iGc->TextShadowColor());

			iGc->SetBrushColor(TRgb(255, 0, 0));

			TEST(TRgb(255, 0, 0) == iGc->BrushColor());

			}

		else

			{

			iGc->SetBrushStyle(DirectGdi::ENullBrush);

			iGc->SetPenStyle(DirectGdi::ESolidPen);

			}	

		iGc->SetPenColor(TRgb(0, 255, 0));

		if(fontType[ii].iFontParam & EItalic)

			{

			fspec.iFontStyle.SetPosture(EPostureItalic);

			}

		if(fontType[ii].iFontParam & EBold)

			{

			fspec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

			}

		User::LeaveIfError(iFontStore->GetNearestFontToDesignHeightInPixels((CFont*&) font, fspec));

		if(iUseDirectGdi)

			{

			if(ii == 2)

				{

				iGc->SetFontNoDuplicate(font);

				(reinterpret_cast <CTestDirectGdiContext*> (iGc))->NoJustifyAutoUpdate();

				}

			else

				{

				iGc->SetFont(font);

				iGc->SetFontNoDuplicate(font);//shoudn't have any impact

				(reinterpret_cast <CTestDirectGdiContext*> (iGc))->SetJustifyAutoUpdate();

				}	

			}

		else

			{

			iGc->SetFont(font);

			iGc->SetFontNoDuplicate(font);//shoudn't have any impact

			}	

		TEST(iGc->HasFont());

		TFontSpec fontSpec = font->FontSpecInTwips();

		TGlyphBitmapType glyphBitmapType = fontSpec.iFontStyle.BitmapType();

		TEST(glyphBitmapType == aGlyphBitmapType);	

		if(fontType[ii].iFontParam & EUnderline)

			{

			iGc->SetUnderlineStyle(DirectGdi::EUnderlineOn);

			}

		else if(fontType[ii].iFontParam & EStrikeThrough)

			{

			iGc->SetStrikethroughStyle(DirectGdi::EStrikethroughOn);

			}

		if(EDrawTextVerticalDown != aDirection)

			{

			*coord += font->HeightInPixels() + 5;

			}

		if(aGlyphStorage && (ii == 0) && (arraySize > 1))

			{

			aGlyphStorage->CleanGlyphImageCache();

			aGlyphStorage->EnforceOOMFailure(ETrue);

			}

		DrawText(KTextOutput, pt, aDirection, aDrawAdjustment, ii == 1);

		if(aGlyphStorage)

			{

			aGlyphStorage->EnforceOOMFailure(EFalse);

			}

		if(EDrawTextVerticalDown == aDirection)

			{

			*coord += font->HeightInPixels() + 5;

			}

		if(fontType[ii].iFontParam == ENormal)

			{

			iGc->SetUnderlineStyle(DirectGdi::EUnderlineOff);

			iGc->SetStrikethroughStyle(DirectGdi::EStrikethroughOff);

			}

		iGc->ResetFont();

		iFontStore->ReleaseFont(font);

		TEST(!iGc->HasFont());

		}

	region.Close();

	if(aClipText)

		{

		iGc->ResetClippingRegion();

		}

	// Write the output to file.

	//

	TESTNOERROR(WriteTargetOutput(iTestParams, testName));

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0003

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Filling up the glyph image cache

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	1.	Fill glyph image storage with the same font but different glyphs until it exceeds its limit and resets the cache.

	Repeat this operation for other glyph types

	2.	Fill glyph image storage with different font and different glyph codes

@SYMTestExpectedResults

	Check that Glyph cache storage increments cache size correctly and deletes the least 

	usable tree.

*/

void CTGlyphImageCache::FillUpCacheL(MFontGlyphImageStorage* aGlyphStorage)

	{

	if(!aGlyphStorage)

		return;

	aGlyphStorage->CleanGlyphImageCache();

	TBuf<128> testName;

	_LIT(KTestName, "GlyphCache_FillUpCache"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	const TSize size(12, 16);

	TUint8* buffer = (TUint8*)User::AllocL(size.iWidth * size.iHeight);

	CleanupStack::PushL(buffer);

	TInt fontId = 10;

	TGlyphBitmapType glyphTypeList[] = 

		{

		EMonochromeGlyphBitmap,

		EAntiAliasedGlyphBitmap,

		EFourColourBlendGlyphBitmap,

		};

	const TInt numGlyphType = sizeof(glyphTypeList) / sizeof(glyphTypeList[0]);

	TESTL(aGlyphStorage->GlyphCacheSize() == 0);

	TInt glyphSizeInByte = 0;

	TInt expectedSize = 0;

	TUint32 glyphCode = 1;

	VGImage foregroundImg = VG_INVALID_HANDLE;

	VGImage shadowImg = VG_INVALID_HANDLE;

	VGImage outlineImg = VG_INVALID_HANDLE;

	for(TInt ii = 0; ii < numGlyphType; ii++)

		{

		TGlyphBitmapType glyphType = glyphTypeList[ii];

		//calculate the actual size of the glyph

		glyphSizeInByte = GlyphImageSizeInByte(glyphType, size);

		TUint maxGlyphSize = aGlyphStorage->MaxGlyphCacheSize() + glyphSizeInByte;

		do 

			{

			TEST(expectedSize == aGlyphStorage->GlyphCacheSize());

			TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), (TGlyphBitmapType)glyphType, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

			TESTNOERRORL(res);

			glyphCode++;

			expectedSize+= glyphSizeInByte; 

			foregroundImg = VG_INVALID_HANDLE;

			shadowImg = VG_INVALID_HANDLE;

			outlineImg = VG_INVALID_HANDLE;

			}while(expectedSize <= maxGlyphSize);

		glyphCode = 1;	

		expectedSize = 0;

		TEST(glyphSizeInByte == aGlyphStorage->GlyphCacheSize());

		aGlyphStorage->CleanGlyphImageCache();

		}

	//now try to filling cache with different fonts and check that last usable font wont be removed

	TUint maxGlyphSize = aGlyphStorage->MaxGlyphCacheSize();

	glyphSizeInByte = GlyphImageSizeInByte(EMonochromeGlyphBitmap, size);

	do 

		{

		TEST(expectedSize == aGlyphStorage->GlyphCacheSize());

		TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), EMonochromeGlyphBitmap, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

		TESTNOERRORL(res);

		glyphCode++;

		expectedSize+= glyphSizeInByte; 

		foregroundImg = VG_INVALID_HANDLE;

		shadowImg = VG_INVALID_HANDLE;

		outlineImg = VG_INVALID_HANDLE;

		}while(expectedSize <= maxGlyphSize);

	fontId += 10;

	glyphCode = 1;

	TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), EMonochromeGlyphBitmap, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

	TEST(glyphSizeInByte == aGlyphStorage->GlyphCacheSize());

	TESTNOERROR(res);

	RArray<TUint32> listFontId;

	aGlyphStorage->FontIdInOrder(listFontId);

	TESTL(listFontId.Count() == 1);

	TEST(listFontId[0] == fontId);

	listFontId.Reset();

	CleanupStack::PopAndDestroy(buffer);

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0004

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Tests filling the glyph image cache with different glyph images

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Specify glyphs which correspond to different fonts, glyph codes.

	Request related VGImages.

	Test the cache size is correct after each operation.

	Get the driver's MDirectGdiDriverCacheSize interface.

	Attempt to set the maximum size of the glyph cache to a size smaller than

	the existing cache size.

	Attempt to set the maximum size of the glyph cache to a size the same as

	the existing cache size.