/*

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

	}