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