/*

* 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:               PtiLanguage class definitions.

*

*/

#ifndef _PTI_KEY_MAPPINGS_H

#define _PTI_KEY_MAPPINGS_H

#include <e32base.h>

#include "PtiDefs.h"

const TInt KPtiKeyDataDeadKeySeparator = 0xffff;

const TInt KPtiPinyinMarker = 0x2460;

const TInt KPtiStrokeMarker = 0x2461;

const TInt KPtiZhuyinMarker = 0x2462;

const TInt KPtiCangjieMarker = 0x2463;

const TInt KPtiGetAllMarker = 0x2464;

// FORWARD DECLARATIONS

class CPtiKeyMapData;

// 

// CPtiQwertyKeymappingsExtension

//

NONSHARABLE_CLASS(CPtiQwertyKeymappingsExtension) : public CBase

	{

	public:

		static CPtiQwertyKeymappingsExtension* NewL();

		~CPtiQwertyKeymappingsExtension();		

	private:

		CPtiQwertyKeymappingsExtension();

	public:

		TUint16 iLastChar;	       // for Vietnamese 			

		TInt16 iLastTone;          // for Vietnamese

		TUint16 iReplaced;	       // for Vietnamese

		TPtiTextCase iVowelCase;   // for Vietnamese

		TPtiKey iLastToneKey;      // for Vietnamese			

	};

//

// TPtiKeyMapping

//

class TPtiKeyMapping  

	{

	public:	

		TInt iIndex;

		TInt iNumChars;

	};

//

// TPtiReplacedMapping

//

const TInt KMaxReplacedMappingCharacters = 5;		

class TPtiReplacedMapping

	{

	public:

		TPtiKey iKey;

		TPtiTextCase iCase;	

		TPtiEngineInputMode iMode;

		TPtiKeyboardType iKeyboardType;

		TInt iNumChars;

		TUint16 iChrs[KMaxReplacedMappingCharacters];

	};	

/**

* MPtiKeyMappings

*

* Interface class for PtiEngine keymapping functionality.

*/

class MPtiKeyMappings

	{

	public:

		virtual ~MPtiKeyMappings() {}

		/**

		* Starts mapping new key. Will return first character bound to given

		* key in given text case. 		

		*

		* @param aKey   A key to be mapped.

		* @param aCase  Text case for mapping operation.

		* @param aMode  Input mode for mapping. This is needed if keymapping data contains

		*               characters for several input modes (used mainly with Chinese

		*               modes). This value will be matched to possible input mode control

		*               characters in keymapping data.

		* @return       First character bound to requested key.

		*/

		virtual TUint16 StartMapping(TPtiKey aKey,

			                         TPtiTextCase aCase,

									 TPtiEngineInputMode aMode = EPtiEngineInputModeNone) = 0;

		/**

		* Continues keymapping sequence. This method should be called when key event

		* comes in while multitapping timer is active. Takes care of cycling through

		* multitapping candidates associated for given key. 

		*

		* @since 2.6

		* @param aKey A key to be mapped.

		* @param aAppend Refernce to boolen variable. This will be set to ETrue if current character in

		*                editor should be replaced (new multitapping candidate was found) and

		*                to EFalse if new character should inserted instead.

		* @param aCase Text case for mapping operation.

		* @return Next character assosiated to given key or the first character if aKey

		*              was different key than previous key press.

		*/									 

		virtual TUint16 NextKey(TPtiKey aKey, TBool &aAppend, TPtiTextCase aCase) = 0;

		/**

		* Returns PtiEngine key code for last StartMapping() call.		

		*

		* @since 2.6

		* @return PtiEngine key code for last StartMapping() call.

		*/

		virtual TPtiKey CurrentKey() = 0;

		/**

		* Replaces keymapping data for given key and case. 

		*

		* @since 2.6

		* @param aKey A key to be replaced.

		* @param aMap New keymapping data for aKey,

		* @param aCase Text case for replaced data.

		* @return KErrNone or system wide error code.

		*/

		virtual TInt ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase) = 0;

		/**

		* Returns key code for key which produces given unicode character (if found).

		*

		* @since 2.6

		* @param aChar A character to be queried.

		* @return Key code for aChar. EPtiKeyNone, if not found.

		*/				

		virtual TPtiKey KeyForCharacter(TUint16 aChar) = 0;

		/**

		* Returns all keymapping data for current key, excluding first character

		* (which is expected to be "get all"-control character).

		* 

		* @param aCase  Text case for which data will be returned.

		* @return Constant descriptor pointing to keymap data.

		* @since 3.0

		*/		

		virtual TPtrC GetAll(TPtiTextCase aCase) = 0;					

	};

/**

* CPtiMappings

*

* Base class for keymapping implementation classes.

* Handles locally replaced keymappings.

*/

class CPtiMappings : public CBase

	{

	public:

		CPtiMappings();

		CPtiMappings(CPtiKeyMapData* aData);

		~CPtiMappings();

		inline CPtiKeyMapData* KeyMapData() const;

		// DEPRECATED

		virtual TInt WriteData(TInt16*);   

		// DEPRECATED		     

		virtual TInt ChunkDataSize() const;

		IMPORT_C TPtiKeyboardType KeyboardType() const;				

	protected:	

		TInt FindReplacedMapping(TPtiKey aKey, TPtiTextCase aCase, TPtiEngineInputMode aMode) const;

		void ReplaceKeyMapLocalL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase, TPtiEngineInputMode aMode);

    public:		

		TPtrC DataForKeyLocal(TPtiKey aKey, TPtiTextCase aCase, TPtiEngineInputMode aMode) const;	

	protected:

		TPtiKey iCurrentKey;	

		TPtiEngineInputMode iCurrentMode;

		TInt iCurrentChar;

		RArray<TPtiReplacedMapping> iReplacedMappings;

		CPtiKeyMapData* iKeyMapData;          // Not owned

		TPtiKeyboardType iKeyboardType;

	};

/**

* CPtiKeyMappings

* 

* Keymappings implementation class for itu-t keyboard 

*/

NONSHARABLE_CLASS(CPtiKeyMappings) : public CPtiMappings, public MPtiKeyMappings

	{

	public:	

		/**

		* DEPRECATED. Leaves with KErrNotSupported.

		*/

		IMPORT_C static CPtiKeyMappings* NewL(TDesC& aData);

		/**

		* DEPRECATED. Leaves with KErrNotSupported.

		*/

		IMPORT_C static CPtiKeyMappings* NewL(TInt16* aData);		

		/**

		* Constructor.

		*/

		IMPORT_C static CPtiKeyMappings* NewL(CPtiKeyMapData* aData);

		IMPORT_C ~CPtiKeyMappings();

		/**

		* Start mapping for given key.

		*

		* @param aKey  Key code for key.

		* @param aCase Cuurrent text case.

		* @param aMode Current input mode. Default value works for most cases.

		* @return First character for given key. 

		*/

		IMPORT_C virtual TUint16 StartMapping(TPtiKey aKey,

			                         TPtiTextCase aCase,

									 TPtiEngineInputMode aMode = EPtiEngineInputModeNone);										 

		/**

		* Continues keymapping sequence. This method should be called when key event

		* comes in while multitapping timer is active. Takes care of cycling through

		* multitapping candidates associated for given key. 

		*

		* @since S60 V2.6

		* @param aKey A key to be mapped.

		* @param Refernce to boolen variable. This will be set to ETrue if current character in

		*        editor should be replaced (new multitapping candidate was found) and

		*        to EFalse if new character should inserted instead.

		* @param aCase Text case for mapping operation.

		* @return Next character assosiated to given key or the first character if aKey

		*              was different key than previous key press.

		*/									 								 

		IMPORT_C TUint16 NextKey(TPtiKey aKey, TBool &aAppend, TPtiTextCase aCase);

		/**

		* Returns key code for key currently being mapped (relates to StartMapping and NextKey).

		*

		* @return Key code for key currently being mapped.

		*/

		inline TPtiKey CurrentKey();

		/**

		* Replaces keymapping data for given key.

		*		

		* @param  aKey  Key code for key to be replaced.

		* @param  aMap  New keymapping data for aKey.

		* @param  aCase Text case.

		* @return KErrNone if succesfull

		*         Otherwise system wide error code.

		*/

		IMPORT_C TInt ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase);

		/**

		* Scans through keymapping data and returns key code for given character.

		*

		* @param  aChar A character to be queried.

		* @return Key code for mtaching key.

		*         EPtiKeyNone if no matching keys found.

		*/

		IMPORT_C TPtiKey KeyForCharacter(TUint16 aChar);

		/**

		* Returns keymapping data for given key.

		*

		* @param aKey    A key to be queried.

		* @param aResult Descritor where resulting data is stored.

		* @param aCase   Text case		 

		*/

		IMPORT_C void GetDataForKey(TPtiKey aKey, TDes& aResult, TPtiTextCase aCase);

		/**

		* Returns all keymapping data for current key, excluding first character

		* (which is expected to be "get all"-control character).

		* 

		* @param aCase  Text case for which data will be returned.

		* @return Constant descriptor pointing to keymap data.

		* @since S60 V3.0

		*/		

		TPtrC GetAll(TPtiTextCase aCase);							

	protected:		

		CPtiKeyMappings();

		CPtiKeyMappings(CPtiKeyMapData* aData);

		TUint16 NextChar(TPtiTextCase aCase);

		inline void KeyCodeToInternal(TPtiKey aKey);

		inline void DeQwertyfyCaseValue(TPtiTextCase& aCase);		

	};

/**

* CPtiQwertyKeyMappings

* 

* Keymappings implementation class for qwerty keyboard.

*/

NONSHARABLE_CLASS(CPtiQwertyKeyMappings) : public CPtiMappings, public MPtiKeyMappings

	{

	public:	 

		/**

		* DEPRECATED. Will leave with KErrNotSupported.

		*/

		IMPORT_C static CPtiQwertyKeyMappings* NewL(TDesC& aData);

		/**

		* DEPRECATED. Will leave with KErrNotSupported.

		*/

		IMPORT_C static CPtiQwertyKeyMappings* NewL(TInt16* aData);

		/**

		* Constructor.

		*/

		IMPORT_C static CPtiQwertyKeyMappings* NewL(CPtiKeyMapData* aData);				

		IMPORT_C ~CPtiQwertyKeyMappings();

		/**

		* Start mapping for given key.

		*

		* @param aKey  Key code for key.

		* @param aCase Cuurrent text case.

		* @param aMode Current input mode. Default value works for most cases.

		* @return First character for given key. 

		*/		

		IMPORT_C TUint16 StartMapping(TPtiKey aKey,

			                          TPtiTextCase aCase,

									  TPtiEngineInputMode aMode = EPtiEngineInputModeNone);

		/**

		* Continues keymapping sequence. This method should be called when key event

		* comes in while multitapping timer is active. Takes care of cycling through

		* multitapping candidates associated for given key. 

		*

		* @since S60 V2.6

		* @param aKey A key to be mapped.

		* @param aAppend Refernce to boolen variable. This will be set to ETrue if current character in

		*                editor should be replaced (new chr-case character was found) and

		*                to EFalse if new character should inserted instead.

		* @param aCase Text case for mapping operation.

		* @return Next character assosiated to given key or the first character if aKey

		*              was different key than previous key press.

		*/									 					  

		IMPORT_C TUint16 NextKey(TPtiKey aKey, TBool &aAppend, TPtiTextCase aCase);

		/**

		* Returns key code for key currently being mapped (relates to StartMapping and NextKey).

		*

		* @return Key code for key currently being mapped.

		*/		

		inline TPtiKey CurrentKey();

		/**

		* Replaces keymapping data for given key.

		*		

		* @param  aKey  Key code for key to be replaced.

		* @param  aMap  New keymapping data for aKey.

		* @param  aCase Text case.

		* @return KErrNone if succesfull

		*         Otherwise system wide error code.

		*/		

		IMPORT_C TInt ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase);

		/**

		* Scans through keymapping data and returns key code for given character.

		*

		* @param  aChar A character to be queried.

		* @return Key code for mtaching key.

		*         EPtiKeyNone if no matching keys found.

		*/		

		IMPORT_C TPtiKey KeyForCharacter(TUint16 aChar);

		/**

		* Returns keymapping data for given key.

		*

		* @param aKey    A key to be queried.

		* @param aResult Descritor where resulting data is stored.

		* @param aCase   Text case		 

		*/		

		IMPORT_C void GetDataForKey(TPtiKey aKey, TDes& aResult, TPtiTextCase aCase);

		/** DEPRECATED */

		TInt WriteData(TInt16* aDest);

		/** DEPRECATED */

		TInt ChunkDataSize() const;

		/** Internal */		

		inline TBool DeadKeyRootFlag() const;

		/** Internal */				

		inline TUint16 DeadKeyRootChar() const;

		/** Internal */				

		inline TBool VowelSequenceFlag() const;

		/** Internal */				

		inline TUint16 VowelSequenceResult() const;

		/** Internal */				

		inline void ClearVowelSequence();

		/** Internal */				

		inline TInt16 DeadKey() const;

		/** Internal */				

		inline void ClearDeadKey();

		/** Internal */				

		inline void ClearLastChar();

		/** Internal */					

		inline void SetLastChar(TInt aLastChar);

		/** Internal */				

		inline TInt GetLastChar() const;

		/** Internal */				

		inline TUint16 ReplacedCharacter();

		/** Internal */				

		inline void SetLastKey(TPtiKey aKey);

		/** Internal */				

		inline TPtiTextCase VowelCase() const;

		/** Internal */				

		inline void ResetVietnameseVowelSequenceAndToneMarks();

		/** Internal */				

		inline TPtiKey LastKey() const;

		/**

		* Returns all keymapping data for current key, excluding first character

		* (which is expected to be "get all"-control character).

		* 

		* @param aCase  Text case for which data will be returned.

		* @return Constant descriptor pointing to keymap data.

		* @since S60 V3.0

		*/		

		TPtrC GetAll(TPtiTextCase aCase);							

		/** Internal */	

		inline void SetFlag(TInt aFlag);

		/** Internal */			

		inline void ResetFlag(TInt aFlag);	

		/**

		* Fills given array with numeric mode mappings defined in keymap data file.

		* Resultin array contains those mappings that are given with "numeric_mode_key"

		* tag in keymap data file.

		*

		* @since S60 V3.2

		* @param aResult An array to be filled with numeric mode mappings.

		*/

		void GetNumericModeKeysFromDataL(RArray<TPtiNumericKeyBinding>& aResult);

		/**

		* Set keyboard type to be used with qwerty keymappings. Default

		* type is EPtiKeyboardStandard4x12 (Nokia E70 style).

		*

		* @param aKeyboardType Keyboard type to be set.

		* @return KErrNone if keyboard type was set.

		*         EErrNotSupported if mapping data does not have block for given keyboard type.

		*/				

		IMPORT_C TInt SetKeyboardType(TPtiKeyboardType aKeyboardType);	

		/**

		* Returns a boolean value indicating whether there is data block available for

		* given keyboard type.

		*

		* @param  aKeyboardType Keyboard type.

		* @return ETrue if there is data block for given keyboard type.

		*         EFalse otherwise

		*/

		IMPORT_C TBool HasDataBlockForKeyboardType(TPtiKeyboardType aKeyboardType) const;			

	public:

		enum

			{

			EDeadKeyRootFlag = 0x01,

			EVowelSeqFlag    = 0x02,

			EPrevKeyInUpperCase = 0x04,

			ETrackVietnameseToneMarksAndVowels = 0x08

			};

	private:			

		CPtiQwertyKeyMappings();	

		CPtiQwertyKeyMappings(CPtiKeyMapData* aData);

		void ConstructL();

		TUint16 NextChar(TPtiTextCase aCase);

		void KeyCodeToInternal(TPtiKey aKey);

		TUint16 GetDeadKeyChar(TPtiKey aKey, TPtiTextCase aCase);

		inline TInt DeadKeyIndex(TUint16 aDeadKeyUnicode);

		inline TBool IsDeadKeyCode(TUint16 aChar) const;

		inline TBool IsModeControlChar(TUint16 aChar) const;

        TUint16 GetCharForMode(TPtiEngineInputMode aMode, TPtrC aChars, TBool aSkipFirst);

		TBool DoesModeCharMatchToInputMode(TUint16 aChar, TPtiEngineInputMode aMode) const;

		TUint16 VowelSequence(TPtiKey aKey1, TPtiKey aKey2, TPtiTextCase aCase) const;	

		TUint16 VietnameseToneMark(TUint16 aPrevChar, TPtiKey aKey);

		TUint16 RepeatingVowelSequence(TPtiKey aKey);

		TPtiKey VowelSeqRootKey(TUint16 aChar);

		inline TBool ChineseChrModeConversionNeeded(TPtiTextCase aCase, TPtiEngineInputMode aMode) const;

		inline TBool IsChnSpecialCharKey(TPtiKey aKey) const;

	private:

		RArray<TPtiKeyMapping> iReservedArray;  		

		TAny* iReservedPtr;

		TUint16 iDeadKey;

		TUint16 iDeadKeyRootChar;

		TUint16 iVowelSeqResult;

		TPtiKey iLastKey;

		TInt iFlags;

		CPtiQwertyKeymappingsExtension* iExtension;

	};

/**

* CPtiHalfQwertyKeyMappings

* 

* Keymappings implementation class for half qwerty keyboard 

*/

NONSHARABLE_CLASS(CPtiHalfQwertyKeyMappings) : public CPtiKeyMappings

    {

    public:

	    IMPORT_C static CPtiHalfQwertyKeyMappings* NewL(CPtiKeyMapData* aData);

        IMPORT_C ~CPtiHalfQwertyKeyMappings();	    

    public: // From MPtiKeyMappings

		IMPORT_C TInt ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap, TPtiTextCase aCase);

		IMPORT_C TPtiKey KeyForCharacter(TUint16 aChar);

		IMPORT_C TPtrC GetAll(TPtiTextCase aCase);	  

        /**

		* Fills given array with numeric mode mappings defined in keymap data file.

		* Resultin array contains those mappings that are given with "numeric_mode_key"

		* tag in keymap data file.

		*

		* @since S60 V5.0

		* @param aResult An array to be filled with numeric mode mappings.

		*/

		void GetNumericModeKeysFromDataL(RArray<TPtiNumericKeyBinding>& aResult);

	    /**

		* Returns keymapping data for given key.

		*

		* @since S60 V5.0		

		* @param aKey    A key to be queried.

		* @param aResult Descritor where resulting data is stored.

		* @param aCase   Text case		 

		*/		

		IMPORT_C void GetDataForKey(TPtiKey aKey, TDes& aResult, TPtiTextCase aCase);				

		/**

		* Starts mapping new key. Will return first character bound to given

		* key in given text case. 		

		*

		* @param aKey   A key to be mapped.

		* @param aCase  Text case for mapping operation.

		* @param aMode  Input mode for mapping. This is needed if keymapping data contains

		*               characters for several input modes (used mainly with Chinese

		*               modes). This value will be matched to possible input mode control

		*               characters in keymapping data.

		* @return       First character bound to requested key.

		*/

		IMPORT_C TUint16 StartMapping(TPtiKey aKey, TPtiTextCase aCase,

                                               TPtiEngineInputMode aMode = EPtiEngineInputModeNone);

        /**

		* Continues keymapping sequence. This method should be called when key event

		* comes in while multitapping timer is active. Takes care of cycling through

		* multitapping candidates associated for given key. 

		*

		* @since S60 V5.0

		* @param aKey A key to be mapped.

		* @param aAppend Refernce to boolen variable. This will be set to ETrue if current character in

		*                editor should be replaced (new chr-case character was found) and

		*                to EFalse if new character should inserted instead.

		* @param aCase Text case for mapping operation.

		* @return Next character assosiated to given key or the first character if aKey

		*              was different key than previous key press.

		*/									 					  

		IMPORT_C TUint16 NextKey(TPtiKey aKey, TBool &aAppend, TPtiTextCase aCase);

	protected:	

		TUint16 NextChar(TPtiTextCase aCase);

    private:

        CPtiHalfQwertyKeyMappings(CPtiKeyMapData* aData);		  

    };

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

// CPtiKeyMappings::CurrentKey

// 

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

// 

inline TPtiKey CPtiKeyMappings::CurrentKey()

	{

	return iCurrentKey;

	}

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

// CPtiQwertyKeyMappings::CurrentKey

// 

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

// 

inline TPtiKey CPtiQwertyKeyMappings::CurrentKey()

	{

	return iCurrentKey;

	}

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

// CPtiQwertyKeyMappings::DeadKeyIndex

// 

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

// 

inline TInt CPtiQwertyKeyMappings::DeadKeyIndex(TUint16 aDeadKeyUnicode)

	{

	return (aDeadKeyUnicode & 0x00ff);

	}

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

// CPtiQwertyKeyMappings::IsDeadKeyCode

// 

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

// 

inline TBool CPtiQwertyKeyMappings::IsDeadKeyCode(TUint16 aChar) const

	{

	if (((aChar & 0xff00) == 0xf000) &&

	    ((aChar & 0xff) <= 5))

		{

		return ETrue;	

		}

	return EFalse;	

	}

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

// CPtiQwertyKeyMappings::DeadKeyRootFlag

// 

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

// 

inline TBool CPtiQwertyKeyMappings::DeadKeyRootFlag() const

	{

	return (iFlags & EDeadKeyRootFlag) != 0;		

	}

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

// CPtiQwertyKeyMappings::IsModeControlChar

// 

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

// 

inline TBool CPtiQwertyKeyMappings::IsModeControlChar(TUint16 aChar) const

	{

	if ((aChar == KPtiPinyinMarker) ||

		(aChar == KPtiStrokeMarker) ||

		(aChar == KPtiZhuyinMarker) ||

		(aChar == KPtiCangjieMarker))

		{	

		return ETrue;

		}

	return EFalse;

	}

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

// CPtiQwertyKeyMappings::VowelSequenceFlag

// 

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

// 

inline TBool CPtiQwertyKeyMappings::VowelSequenceFlag() const

	{

	return (iFlags & EVowelSeqFlag) != 0;

	}

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

// CPtiQwertyKeyMappings::SetFlag

// 

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

// 

inline void CPtiQwertyKeyMappings::SetFlag(TInt aFlag)

	{

	iFlags |= aFlag;	

	}

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

// CPtiQwertyKeyMappings::ResertFlag

// 

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

// 

inline void CPtiQwertyKeyMappings::ResetFlag(TInt aFlag)

	{	

	iFlags &= ~aFlag;	

	}

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

// CPtiQwertyKeyMappings::VowelSequenceResult

// 

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

// 

inline TUint16 CPtiQwertyKeyMappings::VowelSequenceResult() const

	{

	return iVowelSeqResult;

	}

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

// CPtiQwertyKeyMappings::ClearVowelSequence

// 

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

// 

inline void CPtiQwertyKeyMappings::ClearVowelSequence()

	{

	iLastKey = EPtiKeyNone;

	}

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

// CPtiQwertyKeyMappings::DeadKeyRootChar

// 

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

// 		

inline TUint16 CPtiQwertyKeyMappings::DeadKeyRootChar() const

	{

	return iDeadKeyRootChar;	

	}

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

// CPtiQwertyKeyMappings::DeadKey

// 

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

// 	

inline TInt16 CPtiQwertyKeyMappings::DeadKey() const

	{

	return iDeadKey;	

	}	

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

// CPtiQwertyKeyMappings::ClearDeadKey

// 

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

// 

inline void CPtiQwertyKeyMappings::ClearDeadKey()

	{

	iDeadKey = 0;

	}

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

// CPtiQwertyKeyMappings::ClearLastChar

// 

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

// 	

inline void CPtiQwertyKeyMappings::ClearLastChar()

	{

	iExtension->iLastChar = 0;

	}

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

// CPtiQwertyKeyMappings::SetLastChar

// 

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

// 	

inline void CPtiQwertyKeyMappings::SetLastChar(TInt aLastChar)

	{

	iExtension->iLastChar = (TUint16)aLastChar;

	}

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

// CPtiQwertyKeyMappings::GetLastChar

// 

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

// 	

inline TInt CPtiQwertyKeyMappings::GetLastChar() const

	{

	return iExtension->iLastChar;

	}

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

// CPtiQwertyKeyMappings::ReplacedCharacter

// 

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

// 	

inline TUint16 CPtiQwertyKeyMappings::ReplacedCharacter()

	{	

	return iExtension->iReplaced;

	}

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

// CPtiQwertyKeyMappings::SetLastKey

// 

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

// 		

inline void CPtiQwertyKeyMappings::SetLastKey(TPtiKey aKey)

	{

	iLastKey = aKey;	

	}

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

// CPtiQwertyKeyMappings::KeyCodeToInternal

// 

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

// 				

inline void CPtiKeyMappings::KeyCodeToInternal(TPtiKey aKey)

	{

	iCurrentKey = aKey;

	}

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

// CPtiQwertyKeyMappings::VowelCase

// 

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

// 

inline TPtiTextCase CPtiQwertyKeyMappings::VowelCase() const

	{

	return iExtension->iVowelCase;

	}

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

// CPtiQwertyKeyMappings::ResetVietnameseVowelSequenceAndToneMarks

// 

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

// 

inline void CPtiQwertyKeyMappings::ResetVietnameseVowelSequenceAndToneMarks()

	{

	iExtension->iLastChar = 0;

	iExtension->iReplaced = 0;

	iExtension->iLastTone = 0;

	iVowelSeqResult = 0;

	iLastKey = EPtiKeyNone;

	ResetFlag(EVowelSeqFlag);

	}

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

// CPtiQwertyKeyMappings::LastKey

// 

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

// 

inline TPtiKey CPtiQwertyKeyMappings::LastKey() const

	{

	return iLastKey;

	}

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

// CPtiQwertyKeyMappings::ChineseChrModeConversionNeeded

// 

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

// 

inline TBool CPtiQwertyKeyMappings::ChineseChrModeConversionNeeded(TPtiTextCase aCase, 

                                                         TPtiEngineInputMode aMode) const

	{

	if (aCase == EPtiCaseChrLower &&

       (aMode == EPtiEnginePinyinQwerty  || aMode ==  EPtiEnginePinyinPhraseQwerty ||

        aMode == EPtiEngineStrokeQwerty  || aMode ==EPtiEngineNormalCangjieQwerty  ||

        aMode == EPtiEngineZhuyinQwerty  || aMode == EPtiEngineZhuyinPhraseQwerty  ||

        aMode == EPtiEngineStrokePhraseQwerty))

		{

		return ETrue;

		}

	return EFalse;

	}

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

// CPtiKeyMappings::DeQwertyfyCaseValue

// 

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

// 	

inline void CPtiKeyMappings::DeQwertyfyCaseValue(TPtiTextCase& aCase)

	{

	if (aCase == EPtiCaseChrLower)

		{

		aCase = EPtiCaseLower;

		}

	else if (aCase == EPtiCaseChrUpper)

		{

		aCase = EPtiCaseUpper;

		}		

	}

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

// CPtiKeyMappings::KeyMapData

// 

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

// 		

inline CPtiKeyMapData* CPtiMappings::KeyMapData() const

	{

	return iKeyMapData;

	}

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

// CPtiKeyMappings::IsChnSpecialCharKey

// 

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

// 		

inline TBool CPtiQwertyKeyMappings::IsChnSpecialCharKey(TPtiKey aKey) const

	{

	if (aKey == EPtiKeyQwertyPlus  ||

    	aKey == EPtiKeyQwertyMinus ||

        aKey == EPtiKeyQwertyComma ||

        aKey == EPtiKeyQwertySemicolon ||

    	aKey == EPtiKeyQwertyFullstop ||

    	aKey == EPtiKeyQwertyHash     ||

    	aKey == EPtiKeyQwertySlash    ||

        aKey == EPtiKeyQwertyApostrophe)

		{

		return ETrue;

		}

	return EFalse;	

	}

#endif // _PTI_KEY_MAPPINGS_H

// End of file