/*

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