/*

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

 * Implementation of CIcuLayoutEngine

 * This is a CShaper using the Icu Layout Engine.

 *

 */

 // System includes

 #include <e32base.h>

 #include <gdi.h>

 #include <e32math.h>

 #include <openfont.h>

 #include <fntstore.h>

 // ICU includes

 #include "math.h"

 #include "LETypes.h"

 #include "LEScripts.h"

 #include "LELanguages.h"

 #include "LayoutEngine.h"

 #include "SymbianFontInstance.h"

 #include "IcuLayoutEngine.h"

 // Icu namespace

 U_NAMESPACE_USE

 // Convert from float to int rounding to the nearest integer

 inline TInt FloatToInt(float a)

 	{

 	return a < 0? static_cast<TInt>(a - 0.5) : static_cast<TInt>(a + 0.5);

 	}

 /** Array of Script Codes that need to be translated into LEScriptCodes for the 

 construction of the LayoutEngine. */

 const LETag scriptCodes[] = {

     zyyyScriptTag, /* 'zyyy' (COMMON) */

     qaaiScriptTag, /* 'qaai' (INHERITED) */

     arabScriptTag, /* 'arab' (ARABIC) */

     armnScriptTag, /* 'armn' (ARMENIAN) */

     bengScriptTag, /* 'beng' (BENGALI) */

     bopoScriptTag, /* 'bopo' (BOPOMOFO) */

     cherScriptTag, /* 'cher' (CHEROKEE) */

     qaacScriptTag, /* 'qaac' (COPTIC) */

     cyrlScriptTag, /* 'cyrl' (CYRILLIC) */

     dsrtScriptTag, /* 'dsrt' (DESERET) */

     devaScriptTag, /* 'deva' (DEVANAGARI) */

     ethiScriptTag, /* 'ethi' (ETHIOPIC) */

     georScriptTag, /* 'geor' (GEORGIAN) */

     gothScriptTag, /* 'goth' (GOTHIC) */

     grekScriptTag, /* 'grek' (GREEK) */

     gujrScriptTag, /* 'gujr' (GUJARATI) */

     guruScriptTag, /* 'guru' (GURMUKHI) */

     haniScriptTag, /* 'hani' (HAN) */

     hangScriptTag, /* 'hang' (HANGUL) */

     hebrScriptTag, /* 'hebr' (HEBREW) */

     hiraScriptTag, /* 'hira' (HIRAGANA) */

     kndaScriptTag, /* 'knda' (KANNADA) */

     kanaScriptTag, /* 'kana' (KATAKANA) */

     khmrScriptTag, /* 'khmr' (KHMER) */

     laooScriptTag, /* 'laoo' (LAO) */

     latnScriptTag, /* 'latn' (LATIN) */

     mlymScriptTag, /* 'mlym' (MALAYALAM) */

     mongScriptTag, /* 'mong' (MONGOLIAN) */

     mymrScriptTag, /* 'mymr' (MYANMAR) */

     ogamScriptTag, /* 'ogam' (OGHAM) */

     italScriptTag, /* 'ital' (OLD_ITALIC) */

     oryaScriptTag, /* 'orya' (ORIYA) */

     runrScriptTag, /* 'runr' (RUNIC) */

     sinhScriptTag, /* 'sinh' (SINHALA) */

     syrcScriptTag, /* 'syrc' (SYRIAC) */

     tamlScriptTag, /* 'taml' (TAMIL) */

     teluScriptTag, /* 'telu' (TELUGU) */

     thaaScriptTag, /* 'thaa' (THAANA) */

     thaiScriptTag, /* 'thai' (THAI) */

     tibtScriptTag, /* 'tibt' (TIBETAN) */

     cansScriptTag, /* 'cans' (CANADIAN_ABORIGINAL) */

     yiiiScriptTag, /* 'yiii' (YI) */

     tglgScriptTag, /* 'tglg' (TAGALOG) */

     hanoScriptTag, /* 'hano' (HANUNOO) */

     buhdScriptTag, /* 'buhd' (BUHID) */

     tagbScriptTag, /* 'tagb' (TAGBANWA) */

     braiScriptTag, /* 'brai' (BRAILLE) */

     cprtScriptTag, /* 'cprt' (CYPRIOT) */

     limbScriptTag, /* 'limb' (LIMBU) */

     linbScriptTag, /* 'linb' (LINEAR_B) */

     osmaScriptTag, /* 'osma' (OSMANYA) */

     shawScriptTag, /* 'shaw' (SHAVIAN) */

     taleScriptTag, /* 'tale' (TAI_LE) */

     ugarScriptTag, /* 'ugar' (UGARITIC) */

     hrktScriptTag  /* 'hrkt' (KATAKANA_OR_HIRAGANA) */

 };

 /** Array of Language Codes that need to be translated into LELanguageCodes for the 

 construction of the LayoutEngine. */

 const LETag languageCodes[] = {

     nullLanguageTag, /* '' (null) */

     araLanguageTag, /* 'ARA' (Arabic) */

     asmLanguageTag, /* 'ASM' (Assamese) */

     benLanguageTag, /* 'BEN' (Bengali) */

     farLanguageTag, /* 'FAR' (Farsi) */

     gujLanguageTag, /* 'GUJ' (Gujarati) */

     hinLanguageTag, /* 'HIN' (Hindi) */

     iwrLanguageTag, /* 'IWR' (Hebrew) */

     jiiLanguageTag, /* 'JII' (Yiddish) */

     janLanguageTag, /* 'JAN' (Japanese) */

     kanLanguageTag, /* 'KAN' (Kannada) */

     kokLanguageTag, /* 'KOK' (Konkani) */

     korLanguageTag, /* 'KOR' (Korean) */

     kshLanguageTag, /* 'KSH' (Kashmiri) */

     malLanguageTag, /* 'MAL' (Malayalam (Traditional)) */

     marLanguageTag, /* 'MAR' (Marathi) */

     mlrLanguageTag, /* 'MLR' (Malayalam (Reformed)) */

     mniLanguageTag, /* 'MNI' (Manipuri) */

     oriLanguageTag, /* 'ORI' (Oriya) */

     sanLanguageTag, /* 'SAN' (Sanscrit) */

     sndLanguageTag, /* 'SND' (Sindhi) */

     snhLanguageTag, /* 'SNH' (Sinhalese) */

     syrLanguageTag, /* 'SYR' (Syriac) */

     tamLanguageTag, /* 'TAM' (Tamil) */

     telLanguageTag, /* 'TEL' (Telugu) */

     thaLanguageTag, /* 'THA' (Thai) */

     urdLanguageTag, /* 'URD' (Urdu) */

     zhpLanguageTag, /* 'ZHP' (Chinese (Phonetic)) */

     zhsLanguageTag, /* 'ZHS' (Chinese (Simplified)) */

     zhtLanguageTag  /* 'ZHT' (Chinese (Traditional)) */

 };

 /**

 Translate the script code passed in to a LEScriptCode

 */ 

 TInt ScriptCode(TUint32 aScript)

 	{

 	TInt scriptCode = -1;

     for (TInt i= 0; i < scriptCodeCount; i++)

     	{

     	if (scriptCodes[i] == aScript)

     		{

     		scriptCode = i;

     		break;

     		}

     	}

     return scriptCode;

 	}

 /**

 Translate the language code passed in to a LELanguageCode

 */

 TInt LanguageCode(TUint32 aLanguage)

 	{

 	TInt languageCode = -1;

     for (TInt i= 0; i < languageCodeCount; i++)

     	{

     	if (languageCodes[i] == aLanguage)

     		{

     		languageCode = i;

     		break;

     		}

     	}

     return languageCode;

 	}

 /**

 Create a instance of CIcuLayoutEngine

 @param aBitmapFont The required font.

 @param aHeap The heap to be used for storage by the engine.

 @return A pointer to the new CIcuLayoutEngine instance.

 */

 CShaper * CIcuLayoutEngine::NewL(CBitmapFont* aBitmapFont, TInt aScript, TInt aLanguage, RHeap* aHeap)

 	{

 	CIcuLayoutEngine* newShaper = new(ELeave)CIcuLayoutEngine(aScript, aLanguage);

 	CleanupStack::PushL(newShaper);

 	newShaper->ConstructL(aBitmapFont, aScript, aLanguage, aHeap);

 	CleanupStack::Pop(); // newShaper

 	return newShaper;	

 	} 

 /**

 Construct an instance of CIcuLayoutEngine 	

 @param aBitMapFont The required font

 @param aHeap The heap to be used for storage by the engine

 @return incase of exceptions with an Error Code

 @see CShaper

  */

 TInt  CIcuLayoutEngine::ConstructL(CBitmapFont* aBitMapFont, TInt aScript, TInt aLanguage, RHeap* aHeap )

 	{

 	// allocate a block of memory from aHeap for the layout engine 

 	// which is accessed via the Umemory class

 	iClientHeap = aHeap;

 	// this needs to be on the heap

 	LEErrorCode fontStatus = LE_NO_ERROR;

 	iFontInstance = new SymbianFontInstance(aBitMapFont, fontStatus, aScript == mlymScriptTag);

 	if(NULL == iFontInstance)

 		{

 		User::Leave(KErrGeneral);

 		}

 	if (fontStatus == LE_MEMORY_ALLOCATION_ERROR)

    		{

    		User::Leave(KErrNoMemory);

    		} 	

    	else if (fontStatus != LE_NO_ERROR)

    		{

    		//note this leave may actually be caused by OOM situations, 

    		//due to the way errors codes are handled in the open source code

    		User::Leave(KErrGeneral);

    	 	}

  	// create and initialise a ICU layout Engine

 	// Note the engine is created using the Umemory heap 

     LEErrorCode success = LE_NO_ERROR;

     // Translate the script code into an LEScriptCode

     TInt scriptCode = ScriptCode(aScript);

     // Translate the language code into an LELanguageCode

     TInt languageCode = LanguageCode(aLanguage);

     // Finally instantiate the LayoutEngine    

 	iEngine = LayoutEngine::layoutEngineFactory(iFontInstance, scriptCode, languageCode, success); 

 	// For debugging - check the total memory used by construction

 #ifdef SHAPER_MEMORY_DEBUG

 	TInt totalAllocSize = 0;

 	TInt used = iHeap->AllocSize(totalAllocSize);

 	RDebug::Print(_L("shaper construction %d cells %d"), totalAllocSize, used);

 #endif

 	if (success == LE_MEMORY_ALLOCATION_ERROR)

 		{

 		User::Leave(KErrNoMemory);	

 		}

 	else if (success != LE_NO_ERROR)

 		{

  		//note this leave may actually be caused by OOM situations, 

  		//due to the way errors codes are handled in the open source code

  		User::Leave(KErrGeneral);

 		}

 	return KErrNone;

 	}

 CIcuLayoutEngine::CIcuLayoutEngine(TUint32 aScript, TUint32 aLanguage):

 	iScript(aScript),

 	iLanguage(aLanguage)

 	{

 	}

 /** 

  Frees all resources owned by ...

  */

  CIcuLayoutEngine::~CIcuLayoutEngine()

 	{

 	// delete the engine instance

 	if ( iEngine )

 		{

 		delete( iEngine );

 		}

 	// delete the font instance from client heap

 	delete( iFontInstance );

 	}

 /**

 Returns the script and the language this shaper has been instansiated with.

 */	

 void* CIcuLayoutEngine::ExtendedInterface (TUid aInterfaceId)

 	{

 	if (aInterfaceId == KUidShaperGetScript)		

 		return (TUint32*)iScript;

 	else

 		if (aInterfaceId == KUidShaperGetLang)

 			return (TUint32*)iLanguage;

 		else

 			return CShaper::ExtendedInterface(aInterfaceId);			

 	}

 /** This is implementation of CShaper::ShapeText for the Icu layout Engine

  The data is taken from TInput and pass to the shaper.

  A memory buffer is allocated on aHeapForOutput starting with TShapeHeader is allocated.

  The results of the shaping are copied into this buffer and passed back via aOutput. 

  @param aOutput On success a new structure containing the results allocated on aHeapForOutput.  

  @param aInput The input text and other parameters.

  @param aHeapForOutput On success, aOutput should be allocated from this and nothing else. 

  		On failure, nothing should be allocated from it.

  @return Error value from one of the system-wide error codes on	failure, KErrNone on success.

  @see CShaper::ShapeText

  */		

 TInt CIcuLayoutEngine::ShapeText(TShapeHeader*& aOutput, const TInput& aInput, RHeap* aHeapForOutput)

 	{

 	// For debugging - the heap before shaping

 	TInt totalAllocSize = 0;

 	TInt used;

 #ifdef SHAPER_MEMORY_DEBUG

 	used = User::Heap().AllocSize(totalAllocSize);

 	RDebug::Print(_L("before shaping %d cells %d bytes used"), used, totalAllocSize);

 #endif

 	iFontInstance->SetSessionHandle(aInput.iSessionHandle);

 	TRAPD( error, IcuShapeTextL(aOutput, aInput, aHeapForOutput));

 	if (error == KErrNoMemory)

 		{

 		used = User::Heap().AllocSize(totalAllocSize);

 		RDebug::Print(_L("shaper out of memory %d cells %d"), totalAllocSize, used);

 		}

 #ifdef SHAPER_MEMORY_DEBUG

 	used = User::Heap().AllocSize(totalAllocSize);

 	RDebug::Print(_L("Shaped %d characters %d glyphs "), aOutput->iCharacterCount, aOutput->iGlyphCount );

 	RDebug::Print(_L("after shaping %d cells %d bytes used"), used, totalAllocSize);

 #endif

 	// hide the ICU error codes as KErrGeneral

 	if ((error == KErrNoMemory) || (error == KErrNone))

 		return error;

 	else

 		return KErrGeneral;		

 	}

 /** This calls the ICU Layout engine to shape the text.  It allocates memory for the results

 and then reads the results.  This memory is freed by the caller.

 This function can leave if OOM.

  @param aOutput On success a new structure containing the results allocated on aHeapForOutput.  

  @param aInput The input text and other parameters.

  @param aHeapForOutput On success, aOutput should be allocated from this and nothing else. 

  		On failure, nothing should be allocated from it.

  @return Error value from one of the system-wide error codes on	failure, KErrNone on success.

  @see CIcuLayoutEngine::ShapeText

  */

 void  CIcuLayoutEngine::IcuShapeTextL(TShapeHeader*& aOutput, const TInput& aInput, RHeap* aHeapForOutput)

 	{

 	LEErrorCode success = LE_NO_ERROR;

 	const LEUnicode * p = (LEUnicode *)aInput.iText->Ptr();

 	TInt noChars = aInput.iEnd - aInput.iStart;

 	// Call to layout  

 	TInt noOfGlyphs = iEngine->layoutChars(

 			p, 							// chars - the input character context

 			aInput.iStart,				// the offset of the first character to process	

 			noChars,					// count - the number of characters to process	// offset

 			aInput.iText->Length(), 	// max - the number of characters in the input context	// size of text

 			FALSE, 						// rightToLeft - TRUE if the characters are in a right to left directional run

 			0, 							// start X

 			0, 							// start Y

 			success);					// result code

 	if (success == LE_MEMORY_ALLOCATION_ERROR)

 		User::Leave(KErrNoMemory);

 	else if (success != LE_NO_ERROR) 

 		{

 		User::Leave(KErrGeneral);

 		}

 	// Get some memory to pass into the layout engine for the results

 	TInt bufferSize = (sizeof(LEGlyphID) + sizeof(le_int32) + sizeof(float) * 2)

 		* noOfGlyphs + sizeof(float) * 2;

 	TUint8* buffer = reinterpret_cast<TUint8*>( User::AllocL(bufferSize) );

 	CleanupStack::PushL(buffer);

 	LEGlyphID* glyphBuffer = reinterpret_cast<LEGlyphID*>(buffer);

 	le_int32* indexBuffer = reinterpret_cast<le_int32*>(glyphBuffer + noOfGlyphs);

 	float* positionBuffer = reinterpret_cast<float*>(indexBuffer + noOfGlyphs);

 	// now get results glyph codes, positions and indices

 	// from the layout engine

 	if (success == LE_NO_ERROR)

 		iEngine->getGlyphs(glyphBuffer, success);

 	if (success == LE_NO_ERROR)

 		iEngine->getGlyphPositions(positionBuffer, success);

 	if (success == LE_NO_ERROR)

 		iEngine->getCharIndices(indexBuffer, aInput.iStart, success);

 	if (success == LE_NO_ERROR)

 		// Reset the memory used by the IcuLayoutEngine

 		iEngine->reset();

 	if (success == LE_MEMORY_ALLOCATION_ERROR)

 		User::Leave(KErrNoMemory);

 	else 

 		if (success != LE_NO_ERROR)

  			{

 			User::Leave(KErrGeneral);

 			}

 	// Some of the glyph codes are 0xFFFF and 0x0001. 0xFFFF is a value used by ICU layout

 	// engine to indicate no glyph, and 0x0001 is used to indicate a ZWJ or a ZWNJ.

 	// These should be stripped out now. A ZWJ or a ZWNJ glyph has no meaning here. Their 

 	// effects on the precedig and proceding characters have already been taken into 

 	// consideration during shaping, so we don't need them anymore.

 	// Also, their presence in the final glyph list was causing GDI to break with GDI:1

 	// i.e. more than 8 glyphs in a glyph cluster.

 	LEGlyphID gidOfZWJ = iFontInstance->mapCharToGlyph(0x200D); // Added by Symbian: 1922 mlyl

 	TInt actualNoOfGlyphs = 0;

 	for (LEGlyphID* p = glyphBuffer + noOfGlyphs; p != glyphBuffer;)

 		{

 		--p;

 		if (*p != 0xFFFF && *p != 0x0001 && *p != gidOfZWJ) // Added by Symbian: 1922 mlyl

 			++actualNoOfGlyphs;

 		}

 	// get some memory to pass back the results,  

 	// This needs to be big enough for a TShapeHeader

 	// plus 10 bytes for every glyph returned (-1 for the 1 byte allocated in TShapeHeader for iBuffer)

 	aOutput = reinterpret_cast<TShapeHeader*>( aHeapForOutput->AllocL(

 		sizeof(TShapeHeader) + (actualNoOfGlyphs * 10) + 3) );

 	// get the results into the shaper structure aOutput 

 	aOutput->iGlyphCount = actualNoOfGlyphs;

 	aOutput->iCharacterCount = noChars;

  	aOutput->iReserved0 = 0;

 	aOutput->iReserved1 = 0;

  	// iBuffer contains 10 bytes for every glyph

  	// the glyph code (4 bytes), position X(2 bytes) Y(2 bytes) and indices(2 bytes)

  	// first is glyph count * 4 byte glyph codes

  	TUint32* glyphOut = reinterpret_cast<TUint32*>(aOutput->iBuffer);

  	TInt16* posOut = reinterpret_cast<TInt16*>(aOutput->iBuffer +

  		(4 * actualNoOfGlyphs));

  	TInt16* indicesOut = reinterpret_cast<TInt16*>(aOutput->iBuffer +

  		(8 * actualNoOfGlyphs) + 4);

  	for (TInt i=0; i < noOfGlyphs; i++)

  		{

  		if (*glyphBuffer != 0xFFFF && *glyphBuffer != 0x0001 && *glyphBuffer != gidOfZWJ) // Added by Symbian: 1922 mlyl

  			{

 	  		*glyphOut++ = *glyphBuffer;

 			*posOut++ = FloatToInt( positionBuffer[0] );

 			*posOut++ = FloatToInt( positionBuffer[1] );

 			*indicesOut++ = *indexBuffer;

  			}

  		++glyphBuffer;

  		positionBuffer += 2;

  		++indexBuffer;

 		}

 	// There is an extra pair of positions: this is the total advance

 	posOut[0] = FloatToInt( positionBuffer[0] );

 	posOut[1] = FloatToInt( positionBuffer[1] );

 	CleanupStack::PopAndDestroy(buffer);	

 	}