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