diff -r 000000000000 -r eb1f2e154e89 inputmethods_pub/ptiengine_iti_api/inc/PtiKeyMappings.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/inputmethods_pub/ptiengine_iti_api/inc/PtiKeyMappings.h Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,947 @@ +/* +* 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 +#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 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& 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 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& 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