/*
* 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);	
	
	}