/*
* Copyright (c) 2008-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 "FNTSTD.H"
#include "t_linkedfontscomparison.h"
#include <hal.h>
#include <test/thashreferenceimages.h>
#include <linkedfonts.h>

/**
@file 

@SYMPurpose structures used to define linked typefaces used in this test, create and 
use linked typefaces, and check against a hash value
*/

/** this is for the group entries
 */
struct TTGroup
	{
	CLinkedTypefaceGroup::TBaselineShift iBaselineShift;
	CLinkedTypefaceGroup::TScalingOption iScalingOption;
	TInt iAntiAliasThreshold; //KMinTInt for do not set;
	TInt iBoldnessPercentage; //KMinTInt for do not set;
	TInt iItalicAngle; //KMinTInt for do not set;
	};

/** this is for linked font elements
 */
struct TTLinkedFontElement
	{
	const TPtrC iTypefaceName;
	TInt iGroup;
	TBool iIsCanonical;
	};

/** this is for the linked typeface table
 */
struct TTLinkedTypeface
	{
	const TPtrC iTypefaceName;
	const TTLinkedFontElement* iElements;
	};

/** this is a plain group
 */ 
const TTGroup KPlainGroup =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};

const TTGroup KGroup1 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set - antialiased	
	KMinTInt, //this value means do not set	- boldness percentage
	KMinTInt, //this value means do not set	- italic angle
	};

const TTGroup KGroup2 =
	{
	CLinkedTypefaceGroup::EBaselineShift,
	CLinkedTypefaceGroup::EScalingUp,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup3 =
	{
	CLinkedTypefaceGroup::EBaselineShift,
	CLinkedTypefaceGroup::EScalingUpOrDown,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup4 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	14, //antialiased	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup5 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	10, //antialiased	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup6 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	100, //boldness percentage	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup7 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	10, //boldness percentage	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup8 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	10, //italic angle	
	};
const TTGroup KGroup9 =
	{
	CLinkedTypefaceGroup::EBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	};
const TTGroup KGroup10 =
	{
	CLinkedTypefaceGroup::ENoBaselineShift,
	CLinkedTypefaceGroup::EScalingNone,
	KMinTInt, //this value means do not set	
	KMinTInt, //this value means do not set	
	40, //large italic angle	
	};

/** all the groups are added to every linked typeface
if there are too many groups then there may be a need for a group list
per linked typeface.  Can have a maximum of 12 groups
*/
const TTGroup* KGroupList[]=
	{
	&KPlainGroup, /* index 0 */	
	&KGroup1,
	&KGroup2,
	&KGroup3,
	&KGroup4,
	&KGroup5,
	&KGroup6,
	&KGroup7,
	&KGroup8,
	&KGroup9,
	&KGroup10,
	};

/** typeface element definitions
 */

/** Latin font
 */
const TTLinkedFontElement KLatinFontCanonical = 
	{
	_L("DejaVu Sans Condensed"),0, ETrue //name, group zero, is canonical
	};
	
/** 
 */
const TTLinkedFontElement KJapaneseNotCanonical =
	{
	_L("TBKomachiG-R"), 0, EFalse	 //name, group zero, not canonical
	};

/** Japanese - to be updated
 */
const TTLinkedFontElement KJapaneseNotCanonicalGroup1 =
	{
	_L("TBKomachiG-R"), 1, EFalse	 //name, group , not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup3 =
	{
	_L("TBKomachiG-R"), 3, EFalse	 //name, group, not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup4 =
	{
	_L("TBKomachiG-R"), 4, EFalse	 //name, group, not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup6 =
	{
	_L("TBKomachiG-R"), 6, EFalse	 //name, group, not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup8 =
	{
	_L("TBKomachiG-R"), 8, EFalse	 //name, group, not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup9 =
	{
	_L("TBKomachiG-R"), 9, EFalse	 //name, group, not canonical
	};
const TTLinkedFontElement KJapaneseNotCanonicalGroup10 =
	{
	_L("TBKomachiG-R"), 10, EFalse	 //name, group, not canonical
	};

const TTLinkedFontElement KLatinFontTTNotCanonicalGroup0 = 
	{
	_L("LinkedFontTestFont"), 0, EFalse
	};

const TTLinkedFontElement KLatinFontTTCanonicalGroup0 = 
	{
	_L("LinkedFontTestFont"), 0, ETrue
	};

/* for use case testing */
const TTLinkedFontElement KLatinFontTTCanonicalGroup2 = 
	{
	_L("LinkedFontTestFont"), 2, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup3 = 
	{
	_L("LinkedFontTestFont"), 3, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup5 = 
	{
	_L("LinkedFontTestFont"), 5, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup7 = 
	{
	_L("LinkedFontTestFont"), 7, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup8 = 
	{
	_L("LinkedFontTestFont"), 8, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup9 = 
	{
	_L("LinkedFontTestFont"), 9, ETrue
	};
const TTLinkedFontElement KLatinFontTTCanonicalGroup10 = 
	{
	_L("LinkedFontTestFont"), 10, ETrue
	};
	
/** Chandas 
 */
const TTLinkedFontElement KHindiCanonical = 
	{
	_L("Chandas"),  0, ETrue
	};

/** Chandas 
 */
const TTLinkedFontElement KHindiNotCanonical = 
	{
	_L("Chandas"),  0, EFalse
	};

/** Information about linked fonts
TLinkedFont1.ttf
Typeface name: LinkedFont1
This will be the dominant font. It contains 178 characters.
Some of the characters (13) are deleted from this file and separated in to other three files.
Characters missing are F, D, J, M, P, S, V, X, Z, a, n, l, y.

TLinkedFont2.ttf
Typeface name: LinkedFont2
Characters available (7):	F, J, M, S, Z, a, y.

TLinkedFont3.ttf
Typeface name: LinkedFont3
Characters available (4):	D, P, x, l

TLinkedFont4.ttf
Typeface name: LinkedFont4
Characters available (2):	V, n

TWithoutLinkedFont.ttf
Typeface name: WithoutLinkedFont
Characters available:	It contains 191 characters U+0020-U+007E and U+00A0-U+00FF
*/	

/** LinkedFont1TT
 */
const TTLinkedFontElement KLinkedFont1TT = 
	{
	_L("LinkedFont1TT"),  0, EFalse
	};

/** LinkedFont2TT
 */
const TTLinkedFontElement KLinkedFont2TTCanonical = 
	{
	_L("LinkedFont2TT"),  0, ETrue
	};

/** LinkedFont3TT
 */
const TTLinkedFontElement KLinkedFont3TT = 
	{
	_L("LinkedFont3TT"),  0, EFalse
	};

/** LinkedFont4TT
 */
const TTLinkedFontElement KLinkedFont4TT = 
	{
	_L("LinkedFont4TT"),  0, EFalse
	};

/** KNullDesC
 */
const TTLinkedFontElement KNullElement = 
	{
	_L(""),  0, EFalse
	};
	
/** linked typeface, this list is terminated by KNullElement
 */
const TTLinkedFontElement KLatinFontHindi[]=
	{
	KLatinFontTTNotCanonicalGroup0,
	KHindiCanonical,
	KNullElement,
	};
/** linked typeface, this list is terminated by KNullElement
 */
const TTLinkedFontElement KLatinFontJapanese[]=
	{
	KLatinFontCanonical,
	KJapaneseNotCanonical,
	KNullElement
	};
/** linked typeface, this list is terminated by KNullElement
 */
const TTLinkedFontElement KLinkedFontTestFonts[]=
	{
	KLinkedFont1TT,
	KLinkedFont2TTCanonical,
	KLinkedFont3TT,
	KLinkedFont4TT,
	KNullElement
	};

const TTLinkedFontElement KJapaneseLatinFontTypeface1[]=
	{
	KLatinFontTTCanonicalGroup2,
	KJapaneseNotCanonicalGroup1,
	KNullElement
	};
const TTLinkedFontElement KJapaneseLatinFontTypeface2[]=
	{
	KLatinFontTTCanonicalGroup3,
	KJapaneseNotCanonicalGroup3,
	KNullElement
	};
const TTLinkedFontElement KJapaneseLatinFontTypeface3[]=
	{
	KLatinFontTTCanonicalGroup5,
	KJapaneseNotCanonicalGroup4,
	KNullElement
	};
const TTLinkedFontElement KJapaneseLatinFontTypeface4[]=
	{
	KLatinFontTTCanonicalGroup7,
	KJapaneseNotCanonicalGroup6,
	KNullElement
	};
const TTLinkedFontElement KJapaneseLatinFontTypeface5[]=
	{
	KLatinFontTTCanonicalGroup8,
	KJapaneseNotCanonicalGroup8,
	KNullElement
	};
const TTLinkedFontElement KJapaneseLatinFontTypeface6[]=
	{
	KLatinFontTTCanonicalGroup9,
	KJapaneseNotCanonicalGroup9,
	KNullElement
	};

const TTLinkedFontElement KJapaneseLatinFontTypeface7[]=
	{
	KLatinFontTTCanonicalGroup10,
	KJapaneseNotCanonicalGroup10,
	KNullElement
	};

const TTLinkedFontElement KEnglishJapanseHindiFont[]=
	{
	KLatinFontTTCanonicalGroup0,
	KJapaneseNotCanonical,
	KHindiNotCanonical,
	KNullElement
	};

/** the linked typeface set, no need to null terminate, sizeof is used for this array
 */
const TTLinkedTypeface KLinkedTypefaces[] =
	{
	//name, list of linked font elements
	{_L("LinkedFontTestFont"), KLinkedFontTestFonts},		
	{_L("LatinFontHindi"), KLatinFontHindi}, 
	{_L("LatinFontJapanese"), KLatinFontJapanese},
	{_L("EnglishJapaneseHindi"), KEnglishJapanseHindiFont},
	{_L("UseCaseFont1"), KJapaneseLatinFontTypeface1},
	{_L("UseCaseFont2"), KJapaneseLatinFontTypeface2},
	{_L("UseCaseFont3"), KJapaneseLatinFontTypeface3},
	{_L("UseCaseFont4"), KJapaneseLatinFontTypeface4},
	{_L("UseCaseFont5"), KJapaneseLatinFontTypeface5},
	{_L("UseCaseFont6"), KJapaneseLatinFontTypeface6},
	{_L("UseCaseFont7"), KJapaneseLatinFontTypeface7},
	};

/** Enum which constains bitwise flags for attrbutes which can be set for each font
 */
enum TFontEffectsFlags
	{
	ENoEffect = 0x0,
	EDropShadowOn = 0x1,
	EOutlineOn = 0x2,
	ESetMonochromeGlyphBitmap  = 0x4,
	ESetAntiAliasedGlyphBitmap = 0x8,
	ESetFourColourBlendGlyphBitmap = 0x10,
	EVerticalDraw = 0x20,
	ERotate90Degrees = 0x40,
	EIsStrikethroughOn = 0x80,
	EIsUnderlineOn = 0x100,
	ESoftEdgeOn = 0x200,
	EAlgorithmicBoldOn = 0x400,
	EDrawUp = 0x800,
	EItalicOn = 0x1000,
	ERegularBoldOn = 0x2000,
	EEndOfList = 0x80000000 //a meta flag
	};

const TInt KLengthOfHashValue = 1000;

/** table used to produce hash string from attributes 
 */
const TPtrC KFontEffectsFlagsString[32]=
	{
	_L("ENoEffect"),
	_L("EDropShadowOn"),
	_L("EOutlineOn"),
	_L("ESetMonochromeGlyphBitmap"),
	_L("ESetAntiAliasedGlyphBitmap"),
	_L("ESetFourColourBlendGlyphBitmap"),
	_L("EVerticalDraw"),
	_L("ERotate90Degrees"),
	_L("EIsStrikethroughOn"),
	_L("EIsUnderlineOn"),
	_L("ESoftEdgeOn"),
	_L("EAlgorithmicBoldOn"),
	_L("EDrawUp"),
	_L("EItalicOn"),
	_L("ERegularBoldOn"),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L(""),
	_L("EEndOfList"),
	};


/**this structure is used to define a test case
 */
struct TTestCase
	{
	const TPtrC iTypeFaceName; //typeface name 
	const TDesC* iOutputString; //the output string
	const TDesC* iTestDecription; //test description
	const TPoint iPosition; //the position
	const TInt* iSizes; // a list of sizes
	const TUint32* iFontAttributes; //a list of font attrbutes (bitwise flags, see above
	};

/** an array of sizes used during testing, terminated by zero
 */
const TInt KFontSizeNormalTesting[]=
	{
	10,
	20,
	35,
	0 
	};

const TInt KFontSizeUseCaseTesting[]=
	{
	8,
	12,
	16,
	35,
	0
	};

/** an array of attributes used during font testing, terminated by EEndOfList
 */
const TUint32 KFontAttributesNormalTest[] =// probably need to expand this with position
	{
	ENoEffect,
	EIsUnderlineOn,
	EIsStrikethroughOn,
	ESetFourColourBlendGlyphBitmap,
	EIsUnderlineOn| EIsStrikethroughOn,
	EAlgorithmicBoldOn,
	EVerticalDraw,
	EVerticalDraw | EIsUnderlineOn,
	EVerticalDraw | EIsUnderlineOn | ERotate90Degrees,
	EEndOfList,
	};

const TUint32 KFontAttributesUseCaseTest[] =// probably need to expand this with position
	{
	ENoEffect,
	ERegularBoldOn,
	ESetAntiAliasedGlyphBitmap,
	EItalicOn,
	EEndOfList,
	};

// here are the output strings which are used for testing
_LIT(KHindiText,"\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020");
_LIT(KEnglishText,"The quick brown fox 123");
_LIT(KEnglishHindiText,"TEST 123 \x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020");
_LIT(KEnglishJapaneseText,"T\x308a\x3093\x3054 ESghy LINKED FONTS 123");
_LIT(KEnglishJapaneseHindiText, "T\x308a\x3093\x3054\x306e EST FOnTS LINKED \x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020 123");
_LIT(KLinkedFontTestString,"lInKED FOnTS");


// test descriptions
_LIT(KEnglishTest,"EnglishTest");
_LIT(KHindiTest,"HindiTest");
_LIT(KEnglishHindiTest,"EnglishHindiTest");
_LIT(KEnglishJapaneseTest,"EnglishJapaneseTest");
_LIT(KLinkedFontTest1,"LinkedFontTest-withLinking");
_LIT(KLinkedFontTest2,"LinkedFontTest-unlinkedFont");
_LIT(KEnglishJapaneseHindiTest,"EnglishJapaneseHindiTest");
_LIT(KUseCaseTest,"UseCaseTest");



_LIT(KTestName0001,"TestCase001");
/** this table defines the test cases:
 font name, string, position, sizes(array), attributes(array)
 */
const TTestCase KTestCases[]=
	{
	{_L("LatinFontHindi"), &KHindiText,&KHindiTest, TPoint(50,50),KFontSizeNormalTesting,	KFontAttributesNormalTest},
	{_L("LatinFontHindi"), &KEnglishText, &KEnglishTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("LatinFontHindi"), &KEnglishHindiText, &KEnglishHindiTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("LatinFontJapanese"),&KEnglishText, &KEnglishTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("LatinFontJapanese"),&KEnglishJapaneseText, &KEnglishJapaneseTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("LinkedFontTestFont"),&KLinkedFontTestString, &KLinkedFontTest1, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("WithoutLinkedFontTT"),&KLinkedFontTestString, &KLinkedFontTest2, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
	{_L("EnglishJapaneseHindi"),&KEnglishJapaneseHindiText, &KEnglishJapaneseHindiTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},

	//use case testing
	{_L("UseCaseFont1"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont2"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont3"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont4"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont5"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont6"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	{_L("UseCaseFont7"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
	};

/** Class used to register the linked typefaces
 */	
class CTLinkedTypefaceCreator : public CBase
	{
public:
	static CTLinkedTypefaceCreator* NewL(CTestStep* aStep);
	void CreateL(); //creates the linked typefaces - will not leave with a registration error, but try the next
	~CTLinkedTypefaceCreator();
private:
	CTLinkedTypefaceCreator(CTestStep* aStep);
	void CreateGroupsL(const TTGroup* aElement[],TInt aNumberOfElements);
	void CreateElementsL(const TTLinkedFontElement* aElements);
	void ConstructL();

private:	
	CTestStep* iStep; //for recording failures, not owned
	RPointerArray<CLinkedTypefaceGroup> iGroups; //owned
	RPointerArray<CLinkedTypefaceElementSpec> iElements; //owned
	CFbsScreenDevice* iDev; //owned
	};

/** static NewL
@return CTLinkedTypefaceCreator* 
 */
CTLinkedTypefaceCreator* CTLinkedTypefaceCreator::NewL(CTestStep* aStep)
	{
	CTLinkedTypefaceCreator*  ptr = new (ELeave) CTLinkedTypefaceCreator(aStep);
	CleanupStack::PushL(ptr);
	ptr->ConstructL();
	CleanupStack::Pop();
	return ptr;
	}	

CTLinkedTypefaceCreator::CTLinkedTypefaceCreator(CTestStep* aStep):iStep(aStep)
	{
		
	}

void CTLinkedTypefaceCreator::ConstructL()
	{
	TDisplayMode mode[4]= {EColor16MAP, EColor16MA, EColor16MU, EColor64K};

	TInt err=KErrNone;
	for (TInt count=0;count<(sizeof(mode)/sizeof(mode[0]));count++)
		{
		TRAP(err, iDev = CFbsScreenDevice::NewL(KNullDesC, mode[count]));
		if (err!=KErrNotSupported)
			{
			return;
			}
		}

	User::LeaveIfError(err);
	}

CTLinkedTypefaceCreator::~CTLinkedTypefaceCreator()
	{
	delete iDev;
	iGroups.ResetAndDestroy();
	iElements.ResetAndDestroy();
	}
	
/** function used to create the linked typefaces
 */
void CTLinkedTypefaceCreator::CreateL()
	{
	CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev);
	CleanupStack::PushL(store);

	for (TInt counter=0; counter< sizeof(KLinkedTypefaces)/sizeof(TTLinkedTypeface);counter++)
		{
		//creating the groups needs to be done for every typeface since ownwership is taken
		//after adding the group to one linked typeface specification
		//leave on any failure e.g. out of memory, which is not expected
		CreateGroupsL(KGroupList, sizeof(KGroupList)/sizeof(TTGroup*));

		//create the linked typeface elements for this linked typeface
		CreateElementsL(KLinkedTypefaces[counter].iElements);

		//add the groups and elements, but first create the spec
		CLinkedTypefaceSpecification* spec = CLinkedTypefaceSpecification::NewLC(KLinkedTypefaces[counter].iTypefaceName);
		
		//add the groups
		for (TInt groupCounter=0; groupCounter<iGroups.Count();groupCounter++)
			{
			spec->AddLinkedTypefaceGroupL(*iGroups[groupCounter]);//ownership is taken
			iGroups[groupCounter]=NULL;
			}

		//add the elements
		for (TInt elementCounter=0; elementCounter<iElements.Count();elementCounter++)
			{
			spec->AddTypefaceAtBackL(*iElements[elementCounter]);//ownership is taken
			iElements[elementCounter]=NULL;
			}
		iElements.ResetAndDestroy();
		iGroups.ResetAndDestroy();

		//register
		TInt err=KErrNone;
		TRAP(err,spec->RegisterLinkedTypefaceL(*store)); //may fail if something is wrong with the tables, want to try to continue

		//do not report test failure if already registered
		iStep->testBooleanTrue(err==KErrNone || err==KErrAlreadyExists, (TText8*)__FILE__, __LINE__);

		//delete spec
		CleanupStack::PopAndDestroy();
		}
	CleanupStack::PopAndDestroy();//store
	}

/** function used to create the groups, note all groups are created at once, and 
added to all linked typefaces

@param aElement array of pointers to groups
@param aNumberOfElements the number of elements in the group
*/
void CTLinkedTypefaceCreator::CreateGroupsL(const TTGroup* aElement[],TInt aNumberOfElements)
	{
	for (TInt counter =0; counter<aNumberOfElements;counter++)
		{
		CLinkedTypefaceGroup* groupPtr= CLinkedTypefaceGroup::NewLC(counter);
		groupPtr->SetScalingOption(aElement[counter]->iScalingOption);
		groupPtr->SetBaselineShift(aElement[counter]->iBaselineShift);

		if (aElement[counter]->iBoldnessPercentage!=KMinTInt)
			{
			groupPtr->SetBoldnessPercentage(aElement[counter]->iBoldnessPercentage);
			}
		if (aElement[counter]->iItalicAngle!=KMinTInt)
			{
			groupPtr->SetItalicAngle(aElement[counter]->iItalicAngle);
			}	
		iGroups.AppendL(groupPtr);
		CleanupStack::Pop();//ptr is now on the RArray
		}
	}

/** creates all the elements for one typeface
iElements is updated

@param aElements pointer to a list of elements, terminated by a typeface with null name 
*/

void CTLinkedTypefaceCreator::CreateElementsL(const TTLinkedFontElement* aElements)
	{
	const TTLinkedFontElement* ptrElementSpec = aElements;
	
	//need a loop to go through all the typefaces 
	for (;ptrElementSpec->iTypefaceName!=KNullDesC;ptrElementSpec++)
		{
		CLinkedTypefaceElementSpec* elementSpec = CLinkedTypefaceElementSpec::NewLC(ptrElementSpec->iTypefaceName,ptrElementSpec->iGroup);
		elementSpec->SetCanonical(ptrElementSpec->iIsCanonical);
		iElements.AppendL(elementSpec);
		CleanupStack::Pop();
		}
	}

// Code for creating fonts, drawing text, and comparing hash value

//Considering the intersection of the screen size for both hw and emulator so that same
//baselined hash can be used to test for both
#define	KScreenWidth 320
#define	KScreenHeight 240

const TInt KNumOfDisplayModes = 12;

/** table of strings of display modes
 */
const TPtrC KDisplayModeNames[KNumOfDisplayModes] = 
	{
	_L("EGray2"),
	_L("EGray4"),
	_L("EGray16"),
	_L("EGray256"),
	_L("EColor16"),
	_L("EColor256"),
	_L("EColor64K"),
	_L("EColor16M"),
	_L("EColor4K"),
	_L("EColor16MU"),
	_L("EColor16MA"),
	_L("EColor16MAP"),
	};

/** a mapping table index from DisplayMode into the table of strings
for supported colour modes.  
The tables of strings do not include ERgb, or ENone.  The value in the table is also
needed for compatibility with CTHashReferenceImages
*/
const TInt KSupportDisplayStringIndex[14] = 
	{
	0, //ENone - use EGray2 output string 
	0, //EGray2,
	1, //EGray4,
	2, //EGray16,
	3, //EGray256,
	4, //EColor16,
	5, //EColor256,
	6, //EColor64K,
	7, //EColor16M,
	7, //ERgb
	8, //EColor4K,
	9, //EColor16MU,
	10,//EColor16MA,
	11,//EColor16MAP,
 	};

/** a helper cleanup class
 */
typedef struct
	{
	CBitmapDevice* device;
	CFont* font;
	} SCleanFont;

/** path where the output file are to be stored (if this is configured in chashreferenceimages.cpp
*/
_LIT(KPath,"c:\\fntstoretest\\%S.mbm");

/** constructor
@param aStep the test step
 */
CTLinkedFontsComparison::CTLinkedFontsComparison(CTestStep *aStep):CTGraphicsBase(aStep),iStep(aStep)
	{	
	}

/** ConstructL
 */
void CTLinkedFontsComparison::ConstructL()
	{
	iFbs = RFbsSession::GetSession();
	User::LeaveIfNull(iFbs);
	iHashUtil = CTHashReferenceImages::NewL(iStep,iFbs,&KPath);
	}

/** Destructor
 */
CTLinkedFontsComparison::~CTLinkedFontsComparison()
	{
	FreeScreenDevice();
	delete iHashUtil;
	if (iFbs)
		iFbs->Disconnect();
	}
	
/**
Auxilary function will be called in case of a leave to release the font
@param aCleanFont font to be released
*/
void CleanUpFont(TAny* aCleanFont)
	{
	SCleanFont* cleanFont= static_cast<SCleanFont*>(aCleanFont);
	(cleanFont->device)->ReleaseFont(cleanFont->font);
	}


class CFbsFontEx : public CFbsFont
	{
public:
	static CBitmapFont* FontAddress(CFbsFont* aFont);
	};

CBitmapFont* CFbsFontEx::FontAddress(CFbsFont* aFont)
	{
	return(((CFbsFontEx*)aFont)->Address());
	}

/**
   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0107

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926, REQ10927, REQ10942, REQ10943, REQ10947, REQ10949

   @SYMTestCaseDesc			This test registers linked typefaces with defintions coming from tables.

   @SYMTestActions 			Register a number of linked typefaces which are defined in a set of tables. 
      				
      						Groups can have the following attributes:
      							CLinkedTypefaceGroup::TBaselineShift
								CLinkedTypefaceGroup::TScalingOption
								AntiAliasingThreshold (integer value)
								BoldnessPercentage (integer value)
								ItalicAngle (integer value)

							Typeface elements can have the following attributes:
								Name
								Group
								Is canonical

							Linked typefaces can have the following attributes:
								Name
								Linked typeface elements
								Groups
 
 							For each linked typeface to be created
 								create linked typeface specification
 								create groups
 								add groups to linked typeface specification
 								create linked typeface elements
 								add linked typeface elements to linked typeface specification
 								register the specification
 
   							To produce new linked typefaces it should be possible to do this by updating
   							the table entries.   							

   							The linked typefaces should be valid.  This test requires that the internal test
   							fonts be present.

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1)For each linked typeface, create the groups, create the linked typeface elements,
   							create a linked typeface, add the groups and elements, and 
   						 	register the linked typeface with the font and bitmap server.	

   @SYMTestExpectedResults	(1) - linked font registration succeeds with no panics or leaves.  If the test is run a
   								second time then KErrAlreadyExists is returned, which is not a failure.
*/	
void CTLinkedFontsComparison::RegisterLinkedTypefacesL()
	{
	CTLinkedTypefaceCreator* creator = CTLinkedTypefaceCreator::NewL(iStep);
	CleanupStack::PushL(creator);
	creator->CreateL();
	CleanupStack::PopAndDestroy();
	}
	
/** Create the screen device.
@param aMode display mode for which device has to be created
*/
void CTLinkedFontsComparison::CreateBitmapDeviceL(TDisplayMode aMode)
	{
	iBitmap = new(ELeave) CFbsBitmap;
	//Considering the intersection of the screen size for both hw and emulator so that same
	//baselined hash can be used to test for both
	iBitmap->Create(TSize(KScreenWidth, KScreenHeight), aMode);
	iBitmapDevice = CFbsBitmapDevice::NewL(iBitmap);
	User::LeaveIfError(iBitmapDevice->CreateContext((CGraphicsContext*&)iGc));
	iHashUtil->SetScreenDeviceAndBitmap(iBitmapDevice,iBitmap,iGc);
	}

/**
Delete the devices created and gc.
*/
void CTLinkedFontsComparison::FreeScreenDevice()
	{
	delete iBitmapDevice;
	delete iBitmap;
	delete iGc;
	iBitmapDevice = NULL;
	iBitmap = NULL;
	iGc = NULL;
	}

/** Function to generate a meaningful hash string from the test attributes

@param aSize the size of the font
@param aAttributes the attributes of the font 
@see TFontEffectsFlags
@param aTypefaceName the typeface name

@return the buffer with a text description, used for inclusion in the hash string
*/
HBufC* CTLinkedFontsComparison::GenerateTestDescriptionLC(TInt aSize,TUint32 aAttributes, const TPtrC &aTypefaceName, const TDesC &aTestDescription)
	{
	TBuf<KLengthOfHashValue> tempBuffer;
		
	//append the name
	tempBuffer.Append(_L("_"));
	tempBuffer.Append(aTypefaceName);
	tempBuffer.Append(_L("_"));
	tempBuffer.Append(aTestDescription);
	tempBuffer.Append(_L("_"));
	
	//append the size 
	tempBuffer.AppendFormat(_L("_size-%d"),aSize);
	if (aAttributes == 0)
		{
		//output no attributes
		tempBuffer.Append(_L("_"));
		tempBuffer.Append(KFontEffectsFlagsString[0]); //no attributes string
		}
	else
		{
		for (TInt counter=0;counter<31;counter++)
			{
			TInt bit = 1<<counter; //1,2,4,8 etc
			if (bit&aAttributes)
				{
				tempBuffer.Append(_L("_"));
				tempBuffer.Append(KFontEffectsFlagsString[counter+1]);
				}
			}
		}
	return tempBuffer.AllocLC();	
	}

/**
   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0108

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926, REQ10927, REQ10942, REQ10943, REQ10947, REQ10949

   @SYMTestCaseDesc			This test draws fonts and compares a hash value from the output against
   							a value stored in a file.
   							
   @SYMTestActions			The fonts used for this test come from a table, and each font can
   							be tested with a different output string, size, and creation flag.
   							The sizes are typically, 10, 20, 35 pixels.
   							
   							Steps for each font in the test table entry:
   							(1)Create the font
   							(2)For each size
   							  	(3) For each attribute
   							  		(4)Draw the text and compare against the stored hash value
   								  	
   							
   							The font creation parameters are typically:
								ENoEffect : plain font
								EIsUnderlineOn : have underline
								EIsStrikethroughOn : have strikethrough
								ESetFourColourBlendGlyphBitmap : for shadow and outline
								EIsUnderlineOn, EIsStrikethroughOn : both underline and strikethrough	
								EAlgorithmicBoldOn : algorithmic bold on
								EVerticalDraw : vertical text
								EVerticalDraw, EIsUnderlineOn : vertical text and underline 
								
							If more fonts or attribute combinations are required to be tested, then this should be
							achievable by adding table entries.
   							
   							To produce the hash values the test needs to be run with a special version 
   							of test harness where APPEND_NEW_OR_MISSING_HASH_DATA and SAVEBITMAP macros are defined
   							in thashreferenceimages.cpp.  The saved mbm files should be converted to bitmap 
   							for manual checking.  							
   							
   							The fonts used for this tests should have been registered beforehand with 
   							test GRAPHICS-FNTSTORE-LINKEDFONTS-0107.

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) Create the font. Draw text, and compare the hash value against
    							the value in the file tlinkedfontcomparison.ini.  Note that having the same hash
    							value as the ini file does not necessarily mean that the output is correct. 

   @SYMTestExpectedResults	(1) - font creation succeeds
   							(4) - the hash values are the same for each text string output
*/
void CTLinkedFontsComparison::TestDrawTextUsingLinkedFontsL()
	{
	INFO_PRINTF1(_L("TestDrawTextUsingLinkedFontsL()"));
	FreeScreenDevice();
	const TDisplayMode displayMode = EColor16MAP;

	CreateBitmapDeviceL(displayMode);
	
	INFO_PRINTF2(_L("Display mode: %S"), &KDisplayModeNames[KSupportDisplayStringIndex[displayMode]]);

	//for all the tests
	TInt numberOfTestsRun=0;
	for (TInt testCounter = 0; testCounter< sizeof(KTestCases)/sizeof(TTestCase); testCounter++)
		{
		
		//for all the sizes
		const TInt* ptrSizes = KTestCases[testCounter].iSizes;
		for (; *ptrSizes!=0 ;ptrSizes++)
			{
			TInt size = *ptrSizes;
			
			// for all the attributes
			const TUint32 *ptrAttributes = KTestCases[testCounter].iFontAttributes;
			for (;*ptrAttributes!=EEndOfList;ptrAttributes++)
														
				{
				TUint32 attributes = *ptrAttributes;
				
				HBufC* testDescription = GenerateTestDescriptionLC(size,attributes,KTestCases[testCounter].iTypeFaceName,*( KTestCases[testCounter].iTestDecription));
				//this function is used for a fuller description
				
				//conversion from HBufC to TPtrC
				//need this an an argument to the generate hash id function
				TPtrC ptr = TPtrC(testDescription->Des());
				
				//construct a desriptor string, function in hashutility KTestName0001
				HBufC* hashIdString = iHashUtil->GenerateHashIdStringLC(
						KTestName0001,//general name for test
						numberOfTestsRun, //number of sub test
						&ptr,
						0, 				 //fontFaceIndex, index into the name array above, must be zero
						KSupportDisplayStringIndex[static_cast<TInt>(displayMode)],//display mode, converted to text
							//in the hash code this is an index to a string table, which is missing ENone and ERgb
						attributes //was orientation, but just integer at end, no use attributes
						);
				
				DoTestDrawingOutputL(*hashIdString, KTestCases[testCounter].iTypeFaceName, *(KTestCases[testCounter].iOutputString),
								  KTestCases[testCounter].iPosition,size,attributes);
				
				numberOfTestsRun++;
				CleanupStack::PopAndDestroy(2,testDescription);
				}
			}//sizes
		}//test array
	}

/**
Function to create a font, draw the text, and compare the hash value

@param aHashId a string with the hash ID.
@param aFont the font name
@param aOutputString the output string
@param aPosition the position where to draw the text
@param aSize the height of the font in pixels
@param aAttributes the attributes for the font 
@see TFontEffectsFlags
*/
void CTLinkedFontsComparison::DoTestDrawingOutputL(const TDesC& aHashId, const TPtrC& aFont, const TDesC& aOutputString,
		 TPoint aPosition, TInt aSize, TUint32 aAttributes)
	{
	TFontSpec fontSpec;
	PrepareTestEnvironment(fontSpec, aFont, aSize, aAttributes, ETrue, ETrue);
	CFont* font;
	TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec) == KErrNone);
	SCleanFont cleanupFont = {iBitmapDevice, font};
	CleanupStack::PushL(TCleanupItem(CleanUpFont, &cleanupFont));
	
	//may need to add attributes for the font
	CBitmapFont* bitmapFont=CFbsFontEx::FontAddress(static_cast<CFbsFont*>(font));
	if (aAttributes& EItalicOn)
		{
		bitmapFont->iAlgStyle.SetIsItalic(ETrue);
		}
	if (aAttributes& ERegularBoldOn)
		{
		bitmapFont->iAlgStyle.SetIsBold(ETrue);
		}	
	
	iGc->SetBrushColor(KRgbWhite);
	iGc->Clear();
	iGc->SetBrushColor(KRgbYellow);
	iGc->UseFont(font);
	if(EVerticalDraw & aAttributes)
		{
		iGc->DrawTextVertical(aOutputString, aPosition, ERotate90Degrees & aAttributes);
		}
	else
		{
		iGc->DrawText(aOutputString, aPosition);
		}
	iHashUtil->CompareHashValuesL(aHashId);
	CleanupStack::Pop();//font
	iBitmapDevice->ReleaseFont(font);
	iGc->DiscardFont();
	}

/**
Sets the fontspec and gc attributes according to the flags set in STestFontParameters for the test.
Before setting gc attributes it is cleared and reset.
@param aFontSpec holds all effective font settings
@param aSettings holds the flags for setting the fontspec and gc
@param aFontIndex the fonts index of KFontFace to be set as typeface
@param aSetEffects ETrue will set the effects on in fontspec if their flags are enabled. By default it is ETrue.
@param aSetColors ETrue will set the colours in gc from STestFontParameters. By default it is EFalse.
*/
void CTLinkedFontsComparison::PrepareTestEnvironment(TFontSpec &aFontSpec, const TPtrC& aFont, TInt aSize, TUint32 aAttributes,
							TBool aSetEffects, TBool aSetColors)
	{
	//Set the typeface from the font face array
	aFontSpec.iTypeface.iName = aFont;
	aFontSpec.iHeight = aSize;

	//Set the effects on if any of flags for the effects are set in aSettings and aSetEffects is ETrue
	if(aSetEffects)
		{
		aFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, EDropShadowOn & aAttributes);
		aFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, EOutlineOn & aAttributes);
		aFontSpec.iFontStyle.SetEffects(FontEffect::ESoftEdge, ESoftEdgeOn & aAttributes);
		aFontSpec.iFontStyle.SetEffects(FontEffect::EAlgorithmicBold, EAlgorithmicBoldOn & aAttributes);
		}

	iGc->Reset();
	iGc->Clear();
	iGc->SetPenColor(KRgbBlack);
	iGc->SetStrikethroughStyle((EIsStrikethroughOn & aAttributes) ? EStrikethroughOn : EStrikethroughOff);
	iGc->SetUnderlineStyle((EIsUnderlineOn & aAttributes) ? EUnderlineOn : EUnderlineOff);

	//Set the glyph bitmap type
	if(ESetMonochromeGlyphBitmap & aAttributes)
		{
		aFontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap);
		}
	else if(ESetAntiAliasedGlyphBitmap & aAttributes)
		{
		aFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
		}

	//Set the colours in gc if asked for
	if(aSetColors)
		{
		iGc->SetBrushColor(KRgbYellow);
		iGc->SetPenColor(KRgbBlack);
		iGc->SetShadowColor(KRgbGray);
		}
	}

/** Function to determine if the rasterizer has the linked typeface extended interface.

@return ETrue if the linked fonts rasterizer is present. EFalse otherwise
*/
TBool CTLinkedFontsComparison::CheckMonoTypeInstalledL()
	{
	CreateBitmapDeviceL(EColor16MU); //this is just for the bitmap device to get the font

	CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iBitmapDevice);
	CleanupStack::PushL(store);
	
	// Create typeface to be linked
	_LIT(KLinkedTypefaceTT, "LinkedFont1TT");

	CLinkedTypefaceSpecification *typefaceSpec;
	_LIT(KLinkedFont1TTLinkingTest, "LinkedFont1TTLinkingTest");
		
	typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedFont1TTLinkingTest);
	
	CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1);
	typefaceSpec->AddLinkedTypefaceGroupL(*group1);
	CleanupStack::Pop();
	
	// Add first typeface
	CLinkedTypefaceElementSpec *elementSpec1;
	elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceTT, 1);
	elementSpec1->SetCanonical(ETrue);
		
	typefaceSpec->AddTypefaceAtBackL(*elementSpec1);
	CleanupStack::Pop(1, elementSpec1);
	
	// Now try regstering the linked typeface
	TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store));
	CleanupStack::PopAndDestroy(2, store);
	
	if (ret == KErrNone|| ret== KErrAlreadyExists)
		{
		return ETrue;
		}
	else
		{
		INFO_PRINTF1(_L("Linked fonts comparison: no linked fonts rasterizer found"));
		return EFalse;
		}
	}

/** regular RunTestCaseL, a virtual function called by the test framework
 */
void CTLinkedFontsComparison::RunTestCaseL(TInt aCurTestCase)
	{
	((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch (aCurTestCase)
		{
		case 1:
			{
			((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			if (!CheckMonoTypeInstalledL())
				{
				TestComplete();
				};
			break;
			}
		case 2:
			{
			((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0107"));
			RegisterLinkedTypefacesL();
			break;
			}
		case 3:
			{
			((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0108"));
			TestDrawTextUsingLinkedFontsL();
			break;
			}
		default:
			{
			((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			((CTLinkedFontsComparisonStep*)iStep)->CloseTMSGraphicsStep();
			TestComplete();
			break;
			}
		}
	((CTLinkedFontsComparisonStep*)iStep)->RecordTestResultL();
	}

__CONSTRUCT_STEP__(LinkedFontsComparison)