/*

* Copyright (c) 2003-2006 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:   CPtiQwertyKeymappings class implementation.

*

*/

#include "PtiKeyMappings.h"

#include <PtiKeyMapData.h>

// CONSTANTS

#ifdef _DEBUG

_LIT(KPtiNoQwertyKeyMapDataPanic, "PtiEngine: No qwerty keymap data set!");

_LIT(KPtiNoExtensionPanic, "PtiEngine: No extension class created!");

#endif

const TUint16 KEmptyDeadKeySlotMarker = 0xf000;

const TInt KPtiUWithAHorn = 0x01b0;

const TInt KPtiQwertyLowCaseLetterBase = 97;

const TInt KNumVietnameseToneMarks = 5;

const TInt KNumVietnameseToneMarkDataEntries = 24;

class TVietnameseToneMarkData

	{

	public:

		TUint16 iBaseChar;

		TUint16 iToneData[KNumVietnameseToneMarks]; 

	};

const TVietnameseToneMarkData vietnameseToneMarkData[KNumVietnameseToneMarkDataEntries] =

	{

	// for A-based

	{0x0041, {0x00c1, 0x00c0, 0x1ea2, 0x00c3, 0x1ea0}},		

	{0x0061, {0x00e1, 0x00e0, 0x1ea3, 0x00e3, 0x1ea1}},		

	{0x0102, {0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, 0x1eb6}},		

	{0x0103, {0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7}},		

	{0x00c2, {0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac}},		

	{0x00e2, {0x1ea5, 0x1ea7, 0x1ea9, 0x1eab, 0x1ead}},	

	// for E-based

	{0x0045, {0x00c9, 0x00c8, 0x1eba, 0x1ebc, 0x1eb8}},

	{0x0065, {0x00e9, 0x00e8, 0x1ebb, 0x1ebd, 0x1eb9}},		

	{0x00ca, {0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6}},		

	{0x00ea, {0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7}},		

	// for I-based	

	{0x0049, {0x00cd, 0x00cc, 0x1ec8, 0x0128, 0x1eca}},		

	{0x0069, {0x00ed, 0x00ec, 0x1ec9, 0x0129, 0x1ecb}},		

	// for O-based

	{0x004f, {0x00d3, 0x00d2, 0x1ece, 0x00d5, 0x1ecc}},		

	{0x006f, {0x00f3, 0x00f2, 0x1ecf, 0x00f5, 0x1ecd}},		

	{0x00d4, {0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8}},			

	{0x00f4, {0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9}},		

	{0x01a0, {0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2}},		

	{0x01a1, {0x1edb, 0x1edd, 0x1edf, 0x1ee1, 0x1ee3}},		

	// for U-based

	{0x0055, {0x00da, 0x00d9, 0x1ee6, 0x0168, 0x1ee4}},		

	{0x0075, {0x00fa, 0x00f9, 0x1ee7, 0x0169, 0x1ee5}},		

	{0x01af, {0x1ee8, 0x1eea, 0x1eec, 0x1eee, 0x1ef0}},			

	{0x01b0, {0x1ee9, 0x1eeb, 0x1eed, 0x1eef, 0x1ef1}},	

	// for Y based

	{0x0059, {0x00dd, 0x1ef2, 0x1ef6, 0x1ef8, 0x1ef4}},		

	{0x0079, {0x00fd, 0x1ef3, 0x1ef7, 0x1ef9, 0x1ef5}}			

	};

const TPtiKey vietnameseToneMarkKeys[KNumVietnameseToneMarks] = 

    {

    EPtiKeyQwertyS, EPtiKeyQwertyF, EPtiKeyQwertyR, EPtiKeyQwertyX, EPtiKeyQwertyJ	

    };

//

// CPtiQwertyKeymappingsExtension

//

// ---------------------------------------------------------------------------

// CPtiQwertyKeymappingsExtension::NewL

// 

// ---------------------------------------------------------------------------

// 

CPtiQwertyKeymappingsExtension* CPtiQwertyKeymappingsExtension::NewL()

	{

	return new (ELeave)	CPtiQwertyKeymappingsExtension();

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension

// 

// ---------------------------------------------------------------------------

// 	

CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension()

	{	

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension

// 

// ---------------------------------------------------------------------------

// 	

CPtiQwertyKeymappingsExtension::~CPtiQwertyKeymappingsExtension()

	{	

	}

//

// CPtiQwertyKeymappingsExtension

//

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::NewL

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(TDesC& /*aData*/)

	{

	// DEPRECATED

	User::Leave(KErrNotSupported);

	return NULL;

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::NewL

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(TInt16* /*aData*/)

	{

	// DEPRECATED

	User::Leave(KErrNotSupported);

	return NULL;

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::NewL

// 

// ---------------------------------------------------------------------------

// 	

EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(CPtiKeyMapData* aData)

	{

	CPtiQwertyKeyMappings* maps = new (ELeave) CPtiQwertyKeyMappings(aData);

	CleanupStack::PushL(maps);

	maps->ConstructL();

	CleanupStack::Pop(); // maps

	return maps;	

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::CPtiQwertyKeyMappings

// 

// ---------------------------------------------------------------------------

// 

CPtiQwertyKeyMappings::CPtiQwertyKeyMappings()

	{

    iKeyboardType = EPtiKeyboardQwerty4x12;	

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::CPtiQwertyKeyMappings

// 

// ---------------------------------------------------------------------------

// 

CPtiQwertyKeyMappings::CPtiQwertyKeyMappings(CPtiKeyMapData* aData) : CPtiMappings(aData)

	{

	if(aData->HasKeyData(EPtiKeyboardQwerty4x12))

	    {

	    iKeyboardType = EPtiKeyboardQwerty4x12;

	    }

	else if(aData->HasKeyData(EPtiKeyboardQwerty4x10))

        {

        iKeyboardType = EPtiKeyboardQwerty4x10;

        }

	else if(aData->HasKeyData(EPtiKeyboardQwerty3x11))

	    {

	    iKeyboardType = EPtiKeyboardQwerty3x11;

	    }

	else

	    { 

	    iKeyboardType = EPtiKeyboardCustomQwerty;

	    }

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::~CPtiQwertyKeyMappings

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C CPtiQwertyKeyMappings::~CPtiQwertyKeyMappings()

	{

	iReservedArray.Close();

	delete iExtension;

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::ConstructL

// 

// ---------------------------------------------------------------------------

// 

void CPtiQwertyKeyMappings::ConstructL()

	{

	iExtension = CPtiQwertyKeymappingsExtension::NewL(); 	

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::StartMapping

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C TUint16 CPtiQwertyKeyMappings::StartMapping(TPtiKey aKey, TPtiTextCase aCase, 

                                                     TPtiEngineInputMode aMode)

	{

	__ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));	

	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));

	KeyCodeToInternal(aKey);

	ResetFlag(EDeadKeyRootFlag | EVowelSeqFlag);	

	if (iDeadKey)

		{

		TUint16 deadChar = GetDeadKeyChar(iCurrentKey, aCase);

		iDeadKey = 0;

		if (deadChar)

			{

			return deadChar;	

			}

		SetFlag(EDeadKeyRootFlag);	

		return iDeadKeyRootChar;	

		}

	iCurrentChar = 0;

	iExtension->iReplaced = 0;

	TPtrC keyData = DataForKeyLocal(aKey, aCase, EPtiEngineQwerty);	

	TInt chrIndexOffset= 0 ;

	if (aCase == EPtiCaseChrLower)

		{			

		if (IsChnSpecialCharKey(iCurrentKey))

   			{

       		if (aMode == EPtiEnginePinyinQwerty || aMode == EPtiEnginePinyinPhraseQwerty)

   				{

   				chrIndexOffset = 2;

   				}

            else if (aMode == EPtiEngineZhuyinQwerty || aMode == EPtiEngineZhuyinPhraseQwerty)

        		{

        		chrIndexOffset = 2;

        		}  		

			else if (aMode == EPtiEngineStrokeQwerty || aMode == EPtiEngineStrokePhraseQwerty)

    			{

    			chrIndexOffset = 6;

    			}   			   			    		

   			}

   		else if(aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty9)

   		    {

       		if (aMode == EPtiEnginePinyinQwerty || aMode == EPtiEnginePinyinPhraseQwerty)

   				{

   				chrIndexOffset = 2;

   				}

            else if (aMode == EPtiEngineZhuyinQwerty || aMode == EPtiEngineZhuyinPhraseQwerty)

        		{

        		chrIndexOffset = 2;

        		}  		

   		    }

		}

	if (keyData.Length() <= chrIndexOffset)

		{

		return 0;

		}

	if (iFlags & ETrackVietnameseToneMarksAndVowels)

		{

		TUint toneMarked = VietnameseToneMark(iExtension->iLastChar, aKey);

		if (toneMarked)

			{

			/* In case of FnLower Case, Vowel Sequence shouldnt be constructed, instead we should clear the Vowel Sequence  */

			if (aCase != EPtiCaseFnLower)

          {

          iExtension->iLastToneKey = aKey;               

          iVowelSeqResult = toneMarked;       

          SetFlag(EVowelSeqFlag);

          iLastKey = EPtiKeyNone;         

          return toneMarked;

          }

			else

			    {

			    ClearVowelSequence();

                ClearLastChar();

			    }

			}

		}	

	if (iExtension->iLastToneKey == aKey)

		{

		iExtension->iReplaced = iExtension->iLastChar;			

		TChar lastCase = iExtension->iLastChar;

		iExtension->iVowelCase = EPtiCaseLower;		

		if (lastCase.IsUpper())		

			{

			iExtension->iVowelCase = EPtiCaseUpper;

			}

		iVowelSeqResult = 0;							

		}				

	else if (iVowelSeqResult)

		{

		iExtension->iReplaced = RepeatingVowelSequence(aKey);

		if (!iExtension->iReplaced)

			{

			TPtiKey first = VowelSeqRootKey(iVowelSeqResult);

			iVowelSeqResult = VowelSequence(first, aKey, iExtension->iVowelCase);			

			}

		else

			{

			iVowelSeqResult = 0;

			}			

		}

	iExtension->iLastTone = 0;	

	iExtension->iLastToneKey = EPtiKeyNone;	

	TUint16 ret = GetCharForMode(aMode, keyData.Mid(chrIndexOffset),

								(aMode == EPtiEngineQwertyPredictive ||

	                             aMode == EPtiEngineQwerty || aMode == EPtiEngineInputModeNone)

								 && (aCase == EPtiCaseChrLower || aCase == EPtiCaseChrUpper));

	if ((aKey == EPtiKey0) && 

	    (aCase == EPtiCaseChrLower) &&

        (aMode == EPtiEngineZhuyinQwerty  || aMode ==  EPtiEngineZhuyinPhraseQwerty ))

	    {

	    ret = 0;

	    }

	if (ChineseChrModeConversionNeeded(aCase, aMode) &&

	    aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ)

		{

        ret = KPtiQwertyLowCaseLetterBase + aKey - EPtiKeyQwertyA;		

		}

	if (ret == KPtiGetAllMarker)

		{

		return ret;

		}  

	if (IsDeadKeyCode(ret))

		{

		iDeadKey = ret;

		if (keyData.Length() > 1)

			{

			iDeadKeyRootChar = keyData[1];

			}

		return 0;

		}

	TPtiTextCase vowelCase = iExtension->iVowelCase;			

	//  Do not use vowel sequence if user is in Numeric mode (fnLower)

    if (aCase != EPtiCaseFnLower && iVowelSeqResult == 0 && (iFlags & ETrackVietnameseToneMarksAndVowels))  

        {

		vowelCase = (aCase == EPtiCaseUpper || 

		            (iFlags & EPrevKeyInUpperCase) ? EPtiCaseUpper : EPtiCaseLower);		

		iVowelSeqResult = VowelSequence(iLastKey, aKey, vowelCase);		

		}

	if (iVowelSeqResult)

		{	

		iExtension->iVowelCase = vowelCase;

		iExtension->iLastChar = iVowelSeqResult;

		SetFlag(EVowelSeqFlag);

		iLastKey = EPtiKeyNone;

		}

	else

		{

		// This is for vietnamese, iReplaced can be non-zero only for vietnamese.

		if (iExtension->iReplaced != 0 && aKey == EPtiKeyQwertyW)

			{

			if (ret == KPtiUWithAHorn)

				{

				ret = 'w';

				}

			else

				{

				ret = 'W';

				}				

			iLastKey = EPtiKeyNone;

			iExtension->iLastChar = 0;

			}			

		else

			{

			/* In case of FnLower Case, Vowel Sequence shouldnt be constructed, instead we should clear the Vowel Sequence  */

			if(aCase != EPtiCaseFnLower)

			    {

                iLastKey = aKey;

                iExtension->iLastChar = ret;	

			    }

			else

			    {

			    ClearVowelSequence();

			    ClearLastChar();

			    }

			}			

		}

	if (aCase == EPtiCaseUpper || aCase == EPtiCaseChrUpper)

		{

		SetFlag(EPrevKeyInUpperCase);

		}

	else

		{

		ResetFlag(EPrevKeyInUpperCase);

		}

	return ret;		

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::GetDeadKeyChar

// 

// ---------------------------------------------------------------------------

// 

TUint16 CPtiQwertyKeyMappings::GetDeadKeyChar(TPtiKey aKey, TPtiTextCase aCase)

	{

	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));

	TUint deadIndex = DeadKeyIndex(iDeadKey);

	TPtrC deadKeyData = iKeyMapData->DeadKeyDataForKey(iKeyboardType, aKey, aCase);

	if (deadIndex > 0 && deadIndex <= deadKeyData.Length())

		{

		if (deadKeyData[deadIndex - 1] != KEmptyDeadKeySlotMarker)

			{

			return deadKeyData[deadIndex - 1];   

			}

		}

	return 0;	

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::NextChar

// 

// ---------------------------------------------------------------------------

// 

TUint16 CPtiQwertyKeyMappings::NextChar(TPtiTextCase aCase)

	{

	__ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));		

	__ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));

	TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, EPtiEngineQwerty);	

	iCurrentChar++;

	if (iCurrentChar >= keyData.Length())

		{

		iCurrentChar = 0;

		if (aCase == EPtiCaseChrLower || aCase == EPtiCaseChrUpper)

			{

			iCurrentChar++;			

			if (iCurrentChar >= keyData.Length())

				{

				iCurrentChar = 0;

				return 0;

				} 

			} 

		}	

	if (keyData.Length() == 0)

		{

		return 0;

		}

	if (iFlags & ETrackVietnameseToneMarksAndVowels)

		{

		iExtension->iLastChar = keyData[iCurrentChar];

		}		

	return keyData[iCurrentChar];						

	}

// ---------------------------------------------------------------------------

// CPtiQwertyKeyMappings::ReplaceKeyMapL

// 

// ---------------------------------------------------------------------------

// 

EXPORT_C TInt CPtiQwertyKeyMappings::ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap,

                                                    TPtiTextCase aCase)

	{

	__ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));	

	if (iCurrentKey == aKey)

		{		

		iCurrentKey = EPtiKeyNone;

		iCurrentChar = 0;

		iDeadKey = 0;

		iVowelSeqResult = 0;

		iExtension->iLastToneKey = EPtiKeyNone;

		}				

	if (aCase == EPtiCaseChrLower)		

		{

		aCase = EPtiCaseLower;

		}

	else if (aCase == EPtiCaseChrUpper)		

		{

		aCase = EPtiCaseUpper;

		}