/*

 * 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: 

 * Creates test data files that are used by TC_SHAP_shapeText.cpp test. 

 * This tool uses the Unicode test input text defined in inputData.h and

 * shapes the text by calling the IcuLayoutEngine API ShapeText().

 * The result, along with the input text is stored in the test data files with 

 * extensions .dat

 * First, the reference input data is stored in the data files in the following format, seperated by a delimiter - | :

 * Length (of the input data string)	Font typeface name | Font file name | Starting offset in the input string | End offset in the input string | Input text string

 * Then the result of the shaping is stored in data files in the following format:

 * Output glyph count	Output glyphs	Glyph X and Y coordinates	Glyph advances	Glyph indices	Output character count

 * The TC_SHAP_shape_Text test is programmed to read in files in this format, and this format only.

 * This tool needs to be run, and new test data files need to be created everytime the 

 * IcuLayoutEngine shaping rules are changed/edited/appended.

 * IN ORDER TO CREATE NEW TEST DATA FILES USING THIS UTILITY, YOU WILL NEED TO:

 * 1. Add a new TInputData entry in inputData.txt

 * 2. Delete any old data files in %EPOCROOT%epoc32\winscw\c\

 * 3. Run the test.

 * IN ORDER TO GET THE TC_SHAP_shapeText TEST FILE TO USE THIS NEW DATA, YOU WILL NEED TO:

 * 1. Add your new test file in perforce to:

 * IcuLayoutEngine/test/testdata/...

 * They will have been added to %EPOCROOT%epoc32\winscw\c

 * 2. Update the bld.inf file for IcuLayoutEngine to export this file to z:\test\data\...

 * 3. Update the .cpp file by adding the a new literal at the top of the file with the new filename to be used.

 * 4. Update the TC_SHAP_shapeText.iby file in IcuLayoutEngine/test to include the new file.

 * THIS TOOL SHOULD ONLY BE RUN BY SOMEONE WHO KNOWS WHAT HE/SHE IS DOING!!

 *

 */

 #include <e32def.h>

 #include <e32test.h>

 #include <e32std.h>

 #include <f32file.h>

 #include <fntstore.h>

 #include <s32file.h>

 #include <graphics/openfontrasterizer.h>

 #include <graphics/openfontconstants.h>

 #include <graphics/shapeimpl.h>

 #include "inputData.h"

 const TUint32 KDevanagariScriptCode = 0x64657661;

 const TUint32 KKannadaScriptCode = 0x6B6E6461;

 const TUint32 KHindiLanguageCode = 0x48494E20;

 const TUint32 KKannadaLanguageCode = 0x4B414E20;

 const TUint32 KGujaratiScriptCode = 0x67756A72;

 const TUint32 KGujaratiLanguageCode = 0x47554A20;

 const TUint32 KBengaliScriptCode = 0x62656E67;

 const TUint32 KBengaliLanguageCode = 0x42454E20;

 const TUint32 KTamilScriptCode = 0x74616D6C;

 const TUint32 KTamilLanguageCode = 0x54414D20;

 const TUint32 KTeluguScriptCode = 0x74656C75;

 const TUint32 KTeluguLanguageCode = 0x54454C20;

 const TUint32 KGurmukhiScriptCode = 0x67757275;

 const TUint32 KGurmukhiLanguageCode = 0;

 const TUint32 KMalayalamScriptCode = 0x6d6c796d;

 const TUint32 KMalayalamLanguageCode = 0x4d4c5220;

 _LIT16(KDelimiter, "|");

 //RTest Macros etc

 static RTest TheTest(_L("T_SHAP_createTestData"));

 static void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		TheTest(EFalse, aLine);

 		}

 	}

 static  void Check(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

 		TheTest(EFalse, aLine);

 		}

 	}

 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)	

 #define TEST(arg) ::Check((arg), __LINE__)

 /* 

 Used for cleanup of RImplInfoArray implementationArray below 

 This method is stolen from FbsTop.cpp

 */

 LOCAL_C void ResetAndDestroyRImplInfoPtrArray(TAny* aPtr)

 	{

 	RImplInfoPtrArray* array = reinterpret_cast <RImplInfoPtrArray*> (aPtr);

 	array->ResetAndDestroy();

 	}

 /*

 Load all ECOM implemented rasterizer DLLs. 

 This method is stolen from CFbTop::LoadOpenFontLibraries()

 */

 LOCAL_C void LoadOpenFontLibraries(CFontStore* aFontStore)

 	{

 	RImplInfoPtrArray implementationArray;

 	TCleanupItem cleanup(ResetAndDestroyRImplInfoPtrArray, &implementationArray);

 	CleanupStack::PushL(cleanup);

 	TInt error;

 	TInt ecomerror;

 	TInt ecomnotready;

 	TUid uid = {KUidOpenFontRasterizerPlunginInterface};

 	// Making sure that no race situation arises

 	// If ECom is not ready, give it another chance and try again. if it still doesn't work 

 	// after the third try, then it just carries on quietly and fails... 

 	for (ecomnotready =0; ecomnotready <3; ecomnotready++)

 		{

 		TRAP(ecomerror,REComSession::ListImplementationsL(uid,implementationArray));

 		if (!ecomerror)

 			{

 			break;

 			}

 		else

 			{

 			ecomerror = 0; 	

 			User::After(0);

 			}

 		}

 	const TInt availCount = implementationArray.Count();

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

 		{

 		const CImplementationInformation* info = implementationArray[count];

 		TUid rasterizerUid = info->ImplementationUid();

  		// Create a rasterizer

  		COpenFontRasterizer* rasterizer=0;

  		TRAP(error,rasterizer = COpenFontRasterizer::NewL(rasterizerUid));

  		if (!error)

    			{

    			// Install it in the font store.

    			TRAP(error,aFontStore->InstallRasterizerL(rasterizer));

    			if (error)

    				delete rasterizer;

    			}

 		}

 	CleanupStack::PopAndDestroy(&implementationArray); 	

 	}

 LOCAL_C void WriteInputData(RWriteStream& aStream, const TInputData& aInputData)

 	{

 	//output the input data to the file

 	TPtrC input = aInputData.TextInput();

 	TInt length = input.Length();

 	TInt start = aInputData.iStart;

 	if (start < 0)

 		start += length;

 	TInt end = aInputData.iEnd;

 	if (end <= 0)

 		end += length;

 	aStream.WriteInt16L(length);

 	aStream.WriteL(aInputData.TypeFaceName());

 	aStream.WriteL(KDelimiter);

 	aStream.WriteL(aInputData.FontFilename());

 	aStream.WriteL(KDelimiter);

 	aStream.WriteInt16L(start);

 	aStream.WriteL(KDelimiter);

 	aStream.WriteInt16L(end);

 	aStream.WriteL(KDelimiter);

 	aStream.WriteL(input);

 	aStream.WriteL(KDelimiter);

 	}

 static void WriteOutputData(RWriteStream& aStream, const TInputData& aInputData, 

 							TUint32 aScript, TUint32 aLanguage)

 	{

 	//SHAPE THE TEXT

 	TPtrC input = aInputData.TextInput();

 	TInt length = input.Length();

 	TInt start = aInputData.iStart;

 	if (start < 0)

 		start += length;

 	TInt end = aInputData.iEnd;

 	if (end <= 0)

 		end += length;

 	//set up font store and install rasterizer(s)

 	CFontStore* fontStore = CFontStore::NewL(&User::Heap());

 	fontStore->iKPixelWidthInTwips = 11860;

 	fontStore->iKPixelHeightInTwips = 11860;

 	CleanupStack::PushL(fontStore);

 	LoadOpenFontLibraries(fontStore);

 	//add required font file

 	TRAPD( err, fontStore->AddFileL(aInputData.FontFilename()) );

 	TEST(err==KErrNone);

 	CBitmapFont* font;

 	TFontSpec fontSpec(aInputData.TypeFaceName(), 12);

 	fontStore->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec);

 	CleanupStack::PushL(font);

 	CShaper* theShaper = NULL;

 	CShaperFactory* shaperFactory = NULL;

 	RImplInfoPtrArray implementationArray;

 	TCleanupItem cleanup(ResetAndDestroyRImplInfoPtrArray, &implementationArray);

 	CleanupStack::PushL(cleanup);

 	TInt error;

 	TInt ecomerror;

 	TInt ecomnotready;

 	TUid uid = {KUidShaperFactoryPlunginInterface};

 	// Making sure that no race situation arises between FBserv and Ecom

 	// If ECom is not ready, give it another chance and try again. if it still doesn't work 

 	// after the third try, then it just carries on quietly and fails... 

 	for (ecomnotready =0; ecomnotready <3; ecomnotready++)

 		{

        		TRAP(ecomerror,REComSession::ListImplementationsL(uid,implementationArray));

 		if (!ecomerror)

 			{

 			break;

 			}

 		else

 			{

 			ecomerror = 0; 	

 			User::After(0);

 			}

 		}

 	const TInt availCount = implementationArray.Count();

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

 		{

 		const CImplementationInformation* info = implementationArray[count];

 		TUid shaperFactoryUid = info->ImplementationUid();

  		// Create a shaper factory

  		//CShaperFactory* shaperFactory = 0;

  		TRAP(error,shaperFactory = CShaperFactory::NewL(shaperFactoryUid));

    		TEST2(error, KErrNone);

    			// Create a shaper

    		TRAPD(err, theShaper = shaperFactory->NewShaperL(font, aScript, aLanguage, &User::Heap()));

    		TEST2(err, KErrNone);

     	}

 	CleanupStack::PopAndDestroy(&implementationArray); 	

 	CleanupStack::PushL(shaperFactory);

 	CleanupStack::PushL(theShaper);

 	// create the data to be shaped

 	// this uses testData, defined in testData.h

 	CShaper::TInput shaperInput;

 	shaperInput.iText = &input;

 	shaperInput.iStart = start;

 	shaperInput.iEnd = end;

 	TShapeHeader* output = NULL;

 	err = theShaper->ShapeText(output, shaperInput, &User::Heap());

 	TEST2(err,KErrNone);

 	CleanupStack::PushL(output);

 	//AND FILL THE FILE UP WITH THE RESULTS

 	//first the glyph count

 	aStream.WriteInt16L(output->iGlyphCount);

 	TInt glyphCount(output->iGlyphCount);

 	TInt i;

 	//then the Glyphs

 	TUint32* shapePtr32 = (reinterpret_cast<TUint32*>(&output->iBuffer[0]));

 	for(i=0; i <glyphCount; i++)

 		{

 		aStream.WriteInt32L(*shapePtr32);

 		shapePtr32++;

 		}

 	//then the X and Y positions

 	TUint16* shapePtr16 = (reinterpret_cast<TUint16*>(shapePtr32));

 	for(i=0; i<glyphCount*2; i++)

 		{

 		aStream.WriteInt16L(*shapePtr16);

 		shapePtr16++;		

 		}

   	//then the advance

   	aStream.WriteInt16L(*shapePtr16);

 	shapePtr16++;		

   	aStream.WriteInt16L(*shapePtr16);

 	shapePtr16++;		

 	//then the indices

 	for(i=0; i<glyphCount; i++)

 		{

 		aStream.WriteInt16L(*shapePtr16);

 		shapePtr16++;		

 		}	

 	//then the character count

 	aStream.WriteInt16L(output->iCharacterCount);

 	CleanupStack::PopAndDestroy(output);

 	CleanupStack::PopAndDestroy(theShaper);

 	CleanupStack::PopAndDestroy(shaperFactory);

 	REComSession::FinalClose();

 	CleanupStack::Pop(font);  

 	fontStore->ReleaseFont(font);

 	CleanupStack::PopAndDestroy(fontStore);

 	//close the ecom session opened by LoadOpenFontLibraries()

 	REComSession::FinalClose();

 	}

 static void MainL()

 	{

 	RFs fs;

 	RFile file;

 	RFileBuf buf;

 	// Create the Devanagari test data files

 	const TInt numberOfTests

 		= sizeof(TNR_Dev_OTInputData)/sizeof(TNR_Dev_OTInputData[0]);

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

 		{

 		const TInputData& data = TNR_Dev_OTInputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		// note this uses RFile::Create so that users of this utility cannot accidentally write over

 		// files created before. If this test fails, you need to ensure that the file specified by 

 		// KFileName is correct, and if so delete it before running this utility.

 		TEST2(file.Create(fs, data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		//write to the stream

 		WriteInputData(stream, data);

 		WriteOutputData(stream, data, KDevanagariScriptCode, KHindiLanguageCode);

 		CleanupStack::PopAndDestroy(2);	//buf, fs

 		}

 	// Create the Kannada test data files

 	const TInt numberOfKanTests = sizeof(Kannada_InputData)/sizeof(Kannada_InputData[0]);

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

 		{

 		const TInputData& kan_data = Kannada_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, kan_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, kan_data);

 		WriteOutputData(stream, kan_data, KKannadaScriptCode, KKannadaLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// Create the Gujarati test data files

 	const TInt numberOfGujTests = sizeof(Gujarati_InputData)/sizeof(Gujarati_InputData[0]);

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

 		{

 		const TInputData& kan_data = Gujarati_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, kan_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, kan_data);

 		WriteOutputData(stream, kan_data, KGujaratiScriptCode, KGujaratiLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// Create the Bengali test data files

 	const TInt numberOfBenTests = sizeof(Bengali_InputData)/sizeof(Bengali_InputData[0]);

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

 		{

 		const TInputData& ben_data = Bengali_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, ben_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, ben_data);

 		WriteOutputData(stream, ben_data, KBengaliScriptCode, KBengaliLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// Create the Tamil test data files

 	const TInt numberOfTamTests = sizeof(Tamil_InputData)/sizeof(Tamil_InputData[0]);

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

 		{

 		const TInputData& tam_data = Tamil_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, tam_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, tam_data);

 		WriteOutputData(stream, tam_data, KTamilScriptCode, KTamilLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// Create the Telugu test data files

 	const TInt numberOfTelTests = sizeof(Telugu_InputData)/sizeof(Telugu_InputData[0]);

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

 		{

 		const TInputData& tel_data = Telugu_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, tel_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, tel_data);

 		WriteOutputData(stream, tel_data, KTeluguScriptCode, KTeluguLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// Create the Gurmukhi test data files

 	const TInt numberOfGurTests = sizeof(Gurmukhi_InputData)/sizeof(Gurmukhi_InputData[0]);

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

 		{

 		const TInputData& tel_data = Gurmukhi_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, tel_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, tel_data);

 		WriteOutputData(stream, tel_data, KGurmukhiScriptCode, KGurmukhiLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	// 	Create the Malayalam test data files

 	const TInt numberOfMalaTests = sizeof(Malayalam_InputData)/sizeof(Malayalam_InputData[0]);

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

 		{

 		const TInputData& tel_data = Malayalam_InputData[i];

 		User::LeaveIfError(fs.Connect());

 		CleanupClosePushL(fs);

 		TEST2(file.Create(fs, tel_data.OutputFilename(), EFileWrite), KErrNone);

 		CleanupClosePushL(buf);

 		buf.Attach(file);

 		RWriteStream stream(&buf);

 		WriteInputData(stream, tel_data);

 		WriteOutputData(stream, tel_data, KMalayalamScriptCode, KMalayalamLanguageCode);

 		CleanupStack::PopAndDestroy(2);

 		}

 	}

 TInt E32Main()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if(!cleanup)

 		return KErrNoMemory;

 	TRAPD(err, MainL());

 	TEST2(err, KErrNone);

 	delete cleanup;

 	__UHEAP_MARKEND;

 	return KErrNone;

 	}