--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/ptienginev2/src/Ptiqwertykeymappings.cpp Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,945 @@
+/*
+* 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: CPtiQwertyKeymappings class implementation.
+*
+*/
+
+
+#include "PtiKeyMappings.h"
+#include <PtiKeyMapData.h>
+
+// CONSTANTS
+
+#ifdef _DEBUG
+_LIT(KPtiNoQwertyKeyMapDataPanic, "PtiEngine: No qwerty keymap data set!");
+_LIT(KPtiNoExtensionPanic, "PtiEngine: No extension class created!");
+#endif
+
+const TUint16 KEmptyDeadKeySlotMarker = 0xf000;
+const TInt KPtiUWithAHorn = 0x01b0;
+const TInt KPtiQwertyLowCaseLetterBase = 97;
+
+const TInt KNumVietnameseToneMarks = 5;
+const TInt KNumVietnameseToneMarkDataEntries = 24;
+
+class TVietnameseToneMarkData
+ {
+ public:
+ TUint16 iBaseChar;
+ TUint16 iToneData[KNumVietnameseToneMarks];
+ };
+
+
+const TVietnameseToneMarkData vietnameseToneMarkData[KNumVietnameseToneMarkDataEntries] =
+ {
+ // for A-based
+ {0x0041, {0x00c1, 0x00c0, 0x1ea2, 0x00c3, 0x1ea0}},
+ {0x0061, {0x00e1, 0x00e0, 0x1ea3, 0x00e3, 0x1ea1}},
+ {0x0102, {0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, 0x1eb6}},
+ {0x0103, {0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7}},
+ {0x00c2, {0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac}},
+ {0x00e2, {0x1ea5, 0x1ea7, 0x1ea9, 0x1eab, 0x1ead}},
+ // for E-based
+ {0x0045, {0x00c9, 0x00c8, 0x1eba, 0x1ebc, 0x1eb8}},
+ {0x0065, {0x00e9, 0x00e8, 0x1ebb, 0x1ebd, 0x1eb9}},
+ {0x00ca, {0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6}},
+ {0x00ea, {0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7}},
+ // for I-based
+ {0x0049, {0x00cd, 0x00cc, 0x1ec8, 0x0128, 0x1eca}},
+ {0x0069, {0x00ed, 0x00ec, 0x1ec9, 0x0129, 0x1ecb}},
+ // for O-based
+ {0x004f, {0x00d3, 0x00d2, 0x1ece, 0x00d5, 0x1ecc}},
+ {0x006f, {0x00f3, 0x00f2, 0x1ecf, 0x00f5, 0x1ecd}},
+ {0x00d4, {0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8}},
+ {0x00f4, {0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9}},
+ {0x01a0, {0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2}},
+ {0x01a1, {0x1edb, 0x1edd, 0x1edf, 0x1ee1, 0x1ee3}},
+ // for U-based
+ {0x0055, {0x00da, 0x00d9, 0x1ee6, 0x0168, 0x1ee4}},
+ {0x0075, {0x00fa, 0x00f9, 0x1ee7, 0x0169, 0x1ee5}},
+ {0x01af, {0x1ee8, 0x1eea, 0x1eec, 0x1eee, 0x1ef0}},
+ {0x01b0, {0x1ee9, 0x1eeb, 0x1eed, 0x1eef, 0x1ef1}},
+ // for Y based
+ {0x0059, {0x00dd, 0x1ef2, 0x1ef6, 0x1ef8, 0x1ef4}},
+ {0x0079, {0x00fd, 0x1ef3, 0x1ef7, 0x1ef9, 0x1ef5}}
+ };
+
+
+const TPtiKey vietnameseToneMarkKeys[KNumVietnameseToneMarks] =
+ {
+ EPtiKeyQwertyS, EPtiKeyQwertyF, EPtiKeyQwertyR, EPtiKeyQwertyX, EPtiKeyQwertyJ
+ };
+
+
+//
+// CPtiQwertyKeymappingsExtension
+//
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeymappingsExtension::NewL
+//
+// ---------------------------------------------------------------------------
+//
+CPtiQwertyKeymappingsExtension* CPtiQwertyKeymappingsExtension::NewL()
+ {
+ return new (ELeave) CPtiQwertyKeymappingsExtension();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension
+//
+// ---------------------------------------------------------------------------
+//
+CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension()
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeymappingsExtension::CPtiQwertyKeymappingsExtension
+//
+// ---------------------------------------------------------------------------
+//
+CPtiQwertyKeymappingsExtension::~CPtiQwertyKeymappingsExtension()
+ {
+ }
+
+//
+// CPtiQwertyKeymappingsExtension
+//
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::NewL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(TDesC& /*aData*/)
+ {
+ // DEPRECATED
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::NewL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(TInt16* /*aData*/)
+ {
+ // DEPRECATED
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::NewL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CPtiQwertyKeyMappings* CPtiQwertyKeyMappings::NewL(CPtiKeyMapData* aData)
+ {
+ CPtiQwertyKeyMappings* maps = new (ELeave) CPtiQwertyKeyMappings(aData);
+ CleanupStack::PushL(maps);
+ maps->ConstructL();
+ CleanupStack::Pop(); // maps
+ return maps;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::CPtiQwertyKeyMappings
+//
+// ---------------------------------------------------------------------------
+//
+CPtiQwertyKeyMappings::CPtiQwertyKeyMappings()
+ {
+ iKeyboardType = EPtiKeyboardQwerty4x12;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::CPtiQwertyKeyMappings
+//
+// ---------------------------------------------------------------------------
+//
+CPtiQwertyKeyMappings::CPtiQwertyKeyMappings(CPtiKeyMapData* aData) : CPtiMappings(aData)
+ {
+ if(aData->HasKeyData(EPtiKeyboardQwerty4x12))
+ {
+ iKeyboardType = EPtiKeyboardQwerty4x12;
+ }
+ else if(aData->HasKeyData(EPtiKeyboardQwerty4x10))
+ {
+ iKeyboardType = EPtiKeyboardQwerty4x10;
+ }
+ else if(aData->HasKeyData(EPtiKeyboardQwerty3x11))
+ {
+ iKeyboardType = EPtiKeyboardQwerty3x11;
+ }
+ else
+ {
+ iKeyboardType = EPtiKeyboardCustomQwerty;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::~CPtiQwertyKeyMappings
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CPtiQwertyKeyMappings::~CPtiQwertyKeyMappings()
+ {
+ iReservedArray.Close();
+ delete iExtension;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::ConstructL
+//
+// ---------------------------------------------------------------------------
+//
+void CPtiQwertyKeyMappings::ConstructL()
+ {
+ iExtension = CPtiQwertyKeymappingsExtension::NewL();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::StartMapping
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint16 CPtiQwertyKeyMappings::StartMapping(TPtiKey aKey, TPtiTextCase aCase,
+ TPtiEngineInputMode aMode)
+ {
+ __ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ KeyCodeToInternal(aKey);
+
+ ResetFlag(EDeadKeyRootFlag | EVowelSeqFlag);
+
+ if (iDeadKey)
+ {
+ TUint16 deadChar = GetDeadKeyChar(iCurrentKey, aCase);
+ iDeadKey = 0;
+ if (deadChar)
+ {
+ return deadChar;
+ }
+ SetFlag(EDeadKeyRootFlag);
+ return iDeadKeyRootChar;
+ }
+
+ iCurrentChar = 0;
+ iExtension->iReplaced = 0;
+
+ TPtrC keyData = DataForKeyLocal(aKey, aCase, EPtiEngineQwerty);
+
+ TInt chrIndexOffset= 0 ;
+
+ if (aCase == EPtiCaseChrLower)
+ {
+ if (IsChnSpecialCharKey(iCurrentKey))
+ {
+ if (aMode == EPtiEnginePinyinQwerty || aMode == EPtiEnginePinyinPhraseQwerty)
+ {
+ chrIndexOffset = 2;
+ }
+ else if (aMode == EPtiEngineZhuyinQwerty || aMode == EPtiEngineZhuyinPhraseQwerty)
+ {
+ chrIndexOffset = 2;
+ }
+ else if (aMode == EPtiEngineStrokeQwerty || aMode == EPtiEngineStrokePhraseQwerty)
+ {
+ chrIndexOffset = 6;
+ }
+ }
+ else if(aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty9)
+ {
+ if (aMode == EPtiEnginePinyinQwerty || aMode == EPtiEnginePinyinPhraseQwerty)
+ {
+ chrIndexOffset = 2;
+ }
+ else if (aMode == EPtiEngineZhuyinQwerty || aMode == EPtiEngineZhuyinPhraseQwerty)
+ {
+ chrIndexOffset = 2;
+ }
+ }
+ }
+
+ if (keyData.Length() <= chrIndexOffset)
+ {
+ return 0;
+ }
+
+ if (iFlags & ETrackVietnameseToneMarksAndVowels)
+ {
+ TUint toneMarked = VietnameseToneMark(iExtension->iLastChar, aKey);
+ if (toneMarked)
+ {
+ /* In case of FnLower Case, Vowel Sequence shouldnt be constructed, instead we should clear the Vowel Sequence */
+ if (aCase != EPtiCaseFnLower)
+ {
+ iExtension->iLastToneKey = aKey;
+ iVowelSeqResult = toneMarked;
+ SetFlag(EVowelSeqFlag);
+ iLastKey = EPtiKeyNone;
+ return toneMarked;
+ }
+ else
+ {
+ ClearVowelSequence();
+ ClearLastChar();
+ }
+ }
+ }
+
+ if (iExtension->iLastToneKey == aKey)
+ {
+ iExtension->iReplaced = iExtension->iLastChar;
+ TChar lastCase = iExtension->iLastChar;
+ iExtension->iVowelCase = EPtiCaseLower;
+ if (lastCase.IsUpper())
+ {
+ iExtension->iVowelCase = EPtiCaseUpper;
+ }
+ iVowelSeqResult = 0;
+ }
+ else if (iVowelSeqResult)
+ {
+ iExtension->iReplaced = RepeatingVowelSequence(aKey);
+ if (!iExtension->iReplaced)
+ {
+ TPtiKey first = VowelSeqRootKey(iVowelSeqResult);
+ iVowelSeqResult = VowelSequence(first, aKey, iExtension->iVowelCase);
+ }
+ else
+ {
+ iVowelSeqResult = 0;
+ }
+ }
+
+ iExtension->iLastTone = 0;
+ iExtension->iLastToneKey = EPtiKeyNone;
+
+ TUint16 ret = GetCharForMode(aMode, keyData.Mid(chrIndexOffset),
+ (aMode == EPtiEngineQwertyPredictive ||
+ aMode == EPtiEngineQwerty || aMode == EPtiEngineInputModeNone)
+ && (aCase == EPtiCaseChrLower || aCase == EPtiCaseChrUpper));
+
+ if ((aKey == EPtiKey0) &&
+ (aCase == EPtiCaseChrLower) &&
+ (aMode == EPtiEngineZhuyinQwerty || aMode == EPtiEngineZhuyinPhraseQwerty ))
+ {
+ ret = 0;
+ }
+
+ if (ChineseChrModeConversionNeeded(aCase, aMode) &&
+ aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ)
+ {
+ ret = KPtiQwertyLowCaseLetterBase + aKey - EPtiKeyQwertyA;
+ }
+
+ if (ret == KPtiGetAllMarker)
+ {
+ return ret;
+ }
+
+ if (IsDeadKeyCode(ret))
+ {
+ iDeadKey = ret;
+ if (keyData.Length() > 1)
+ {
+ iDeadKeyRootChar = keyData[1];
+ }
+
+ return 0;
+ }
+
+ TPtiTextCase vowelCase = iExtension->iVowelCase;
+ // Do not use vowel sequence if user is in Numeric mode (fnLower)
+ if (aCase != EPtiCaseFnLower && iVowelSeqResult == 0 && (iFlags & ETrackVietnameseToneMarksAndVowels))
+ {
+ vowelCase = (aCase == EPtiCaseUpper ||
+ (iFlags & EPrevKeyInUpperCase) ? EPtiCaseUpper : EPtiCaseLower);
+ iVowelSeqResult = VowelSequence(iLastKey, aKey, vowelCase);
+ }
+
+ if (iVowelSeqResult)
+ {
+ iExtension->iVowelCase = vowelCase;
+ iExtension->iLastChar = iVowelSeqResult;
+ SetFlag(EVowelSeqFlag);
+ iLastKey = EPtiKeyNone;
+ }
+ else
+ {
+ // This is for vietnamese, iReplaced can be non-zero only for vietnamese.
+ if (iExtension->iReplaced != 0 && aKey == EPtiKeyQwertyW)
+ {
+ if (ret == KPtiUWithAHorn)
+ {
+ ret = 'w';
+ }
+ else
+ {
+ ret = 'W';
+ }
+ iLastKey = EPtiKeyNone;
+ iExtension->iLastChar = 0;
+ }
+ else
+ {
+ /* In case of FnLower Case, Vowel Sequence shouldnt be constructed, instead we should clear the Vowel Sequence */
+ if(aCase != EPtiCaseFnLower)
+ {
+ iLastKey = aKey;
+ iExtension->iLastChar = ret;
+ }
+ else
+ {
+ ClearVowelSequence();
+ ClearLastChar();
+ }
+ }
+ }
+
+ if (aCase == EPtiCaseUpper || aCase == EPtiCaseChrUpper)
+ {
+ SetFlag(EPrevKeyInUpperCase);
+ }
+ else
+ {
+ ResetFlag(EPrevKeyInUpperCase);
+ }
+
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::GetDeadKeyChar
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::GetDeadKeyChar(TPtiKey aKey, TPtiTextCase aCase)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TUint deadIndex = DeadKeyIndex(iDeadKey);
+ TPtrC deadKeyData = iKeyMapData->DeadKeyDataForKey(iKeyboardType, aKey, aCase);
+ if (deadIndex > 0 && deadIndex <= deadKeyData.Length())
+ {
+ if (deadKeyData[deadIndex - 1] != KEmptyDeadKeySlotMarker)
+ {
+ return deadKeyData[deadIndex - 1];
+ }
+ }
+
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::NextChar
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::NextChar(TPtiTextCase aCase)
+ {
+ __ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TPtrC keyData = DataForKeyLocal(iCurrentKey, aCase, EPtiEngineQwerty);
+
+ iCurrentChar++;
+ if (iCurrentChar >= keyData.Length())
+ {
+ iCurrentChar = 0;
+ if (aCase == EPtiCaseChrLower || aCase == EPtiCaseChrUpper)
+ {
+ iCurrentChar++;
+ if (iCurrentChar >= keyData.Length())
+ {
+ iCurrentChar = 0;
+ return 0;
+ }
+ }
+ }
+
+ if (keyData.Length() == 0)
+ {
+ return 0;
+ }
+
+ if (iFlags & ETrackVietnameseToneMarksAndVowels)
+ {
+ iExtension->iLastChar = keyData[iCurrentChar];
+ }
+
+ return keyData[iCurrentChar];
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::ReplaceKeyMapL
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPtiQwertyKeyMappings::ReplaceKeyMapL(TPtiKey aKey, TDesC& aMap,
+ TPtiTextCase aCase)
+ {
+ __ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));
+
+ if (iCurrentKey == aKey)
+ {
+ iCurrentKey = EPtiKeyNone;
+ iCurrentChar = 0;
+ iDeadKey = 0;
+ iVowelSeqResult = 0;
+ iExtension->iLastToneKey = EPtiKeyNone;
+ }
+
+ if (aCase == EPtiCaseChrLower)
+ {
+ aCase = EPtiCaseLower;
+ }
+ else if (aCase == EPtiCaseChrUpper)
+ {
+ aCase = EPtiCaseUpper;
+ }
+
+ ReplaceKeyMapLocalL(aKey, aMap, aCase, EPtiEngineQwerty);
+
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::GetCharForMode
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::GetCharForMode(TPtiEngineInputMode aMode, TPtrC aChars, TBool aSkipFirst)
+ {
+ for (TInt i = 0; i < aChars.Length(); i++)
+ {
+ if (!IsModeControlChar(aChars[i]))
+ {
+ if (i == 0 && aSkipFirst && aChars.Length() > 1)
+ {
+ iCurrentChar++;
+ continue;
+ }
+ return aChars[i];
+ }
+ if (DoesModeCharMatchToInputMode(aChars[i], aMode))
+ {
+ if (i + 1 >= aChars.Length())
+ {
+ return 0;
+ }
+ return aChars[i + 1];
+ }
+ i++; // Wrong mode, skip char
+ }
+
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::NextKey
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint16 CPtiQwertyKeyMappings::NextKey(TPtiKey aKey, TBool &aAppend,
+ TPtiTextCase aCase)
+ {
+ if (CurrentKey() == aKey)
+ {
+ aAppend = EFalse;
+ return NextChar(aCase);
+ }
+
+ return StartMapping(aKey, aCase);
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::KeyForCharacter
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TPtiKey CPtiQwertyKeyMappings::KeyForCharacter(TUint16 aChar)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TInt numBindItems = 0;
+ const TPtiKeyBinding* bindings = iKeyMapData->KeyBindingTable(iKeyboardType, numBindItems);
+
+ TPtiTextCase textCase;
+ TPtiKey key;
+ for (TInt i = 0; i < numBindItems; i++)
+ {
+ key = iKeyMapData->KeyForBindingTableIndex(iKeyboardType, i, textCase);
+ if (key != EPtiKeyNone)
+ {
+ TPtrC keyData = DataForKeyLocal(key, textCase, EPtiEngineQwerty);
+ if (keyData.Locate(aChar) != KErrNotFound)
+ {
+ return key;
+ }
+ }
+ }
+
+ return EPtiKeyNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::KeyCodeToInternal
+//
+// ---------------------------------------------------------------------------
+//
+void CPtiQwertyKeyMappings::KeyCodeToInternal(TPtiKey aKey)
+ {
+ iCurrentKey = aKey;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::GetDataForKey
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPtiQwertyKeyMappings::GetDataForKey(TPtiKey aKey, TDes& aResult,
+ TPtiTextCase aCase)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ aResult.Copy(DataForKeyLocal(aKey, aCase, EPtiEngineQwerty).Left(aResult.MaxLength()));
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::DoesModeCharMatchToInputMode
+//
+// ---------------------------------------------------------------------------
+//
+TBool CPtiQwertyKeyMappings::DoesModeCharMatchToInputMode(TUint16 aChar,
+ TPtiEngineInputMode aMode) const
+ {
+ switch (aMode)
+ {
+ case EPtiEnginePinyin:
+ case EPtiEnginePinyinQwerty:
+ case EPtiEnginePinyinPhraseQwerty:
+ if (aChar == KPtiPinyinMarker)
+ {
+ return ETrue;
+ }
+ break;
+ case EPtiEngineStroke:
+ case EPtiEngineStrokeQwerty:
+ case EPtiEngineStrokePhraseQwerty:
+ if (aChar == KPtiStrokeMarker)
+ {
+ return ETrue;
+ }
+ break;
+ case EPtiEngineZhuyin:
+ case EPtiEngineZhuyinQwerty:
+ case EPtiEngineZhuyinPhraseQwerty:
+ case EPtiEngineInputModeZhuyinMiniQwertyFind:
+ if (aChar == KPtiZhuyinMarker)
+ {
+ return ETrue;
+ }
+ break;
+ case EPtiEngineNormalCangjieQwerty:
+ case EPtiEngineEasyCangjieQwerty:
+ case EPtiEngineAdvCangjieQwerty:
+ if (aChar == KPtiCangjieMarker)
+ {
+ return ETrue;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return EFalse;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::VowelSequence
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::VowelSequence(TPtiKey aKey1, TPtiKey aKey2,
+ TPtiTextCase aCase) const
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TPtrC keyData1 = DataForKeyLocal((TPtiKey)aKey1, aCase, EPtiEngineQwerty);
+ TPtrC keyData2 = DataForKeyLocal((TPtiKey)aKey2, aCase, EPtiEngineQwerty);
+
+ // This method tracks Vietnamese vowel sequences.
+ TInt numVowelSeqs = 0;
+ const TVowelSequence* vowelSeqs = iKeyMapData->VowelSequenceTable(iKeyboardType, numVowelSeqs);
+
+ TInt shift = (aCase == EPtiCaseLower ? 0 : 1);
+
+ // This loop is to support keylayouts which
+ // can have numeric scancodes
+ if( keyData1.Length() > 0 && keyData2.Length() > 0 )
+ {
+ // convert to caps to compare with vowel data
+ TChar data1 = keyData1[0];
+ data1 = data1.GetUpperCase();
+
+ TChar data2 = keyData2[0];
+ data2 = data2.GetUpperCase();
+
+ for (TInt i = 0; i < numVowelSeqs; i++)
+ {
+ if (((TPtiKey)(TUint)data1 == (TUint)vowelSeqs[i].iFirst) &&
+ ((TPtiKey)(TUint)data2 == (TUint)vowelSeqs[i].iSecond))
+ {
+ return vowelSeqs[i].iChars[shift];
+ }
+ }
+ }
+
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::RepeatingVowelSequence
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::RepeatingVowelSequence(TPtiKey aKey)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TPtrC keyData = DataForKeyLocal((TPtiKey)aKey, EPtiCaseUpper, EPtiEngineQwerty);
+ if( keyData.Length() > 0 )
+ {
+ TChar data = keyData[0];
+ aKey = (TPtiKey)(TUint)data;
+ }
+
+ TInt numVowelSeqs = 0;
+ const TVowelSequence* vowelSeqs = iKeyMapData->VowelSequenceTable(iKeyboardType, numVowelSeqs);
+
+ for (TInt i = 0; i < numVowelSeqs; i++)
+ {
+ if (vowelSeqs[i].iSecond == aKey)
+ {
+ if (iVowelSeqResult == vowelSeqs[i].iChars[0] ||
+ iVowelSeqResult == vowelSeqs[i].iChars[1])
+ {
+ return vowelSeqs[i].iFirst;
+ }
+ }
+ }
+
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::VowelSeqRootKey
+//
+// ---------------------------------------------------------------------------
+//
+TPtiKey CPtiQwertyKeyMappings::VowelSeqRootKey(TUint16 aChar)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TInt numVowelSeqs = 0;
+ const TVowelSequence* vowelSeqs = iKeyMapData->VowelSequenceTable(iKeyboardType, numVowelSeqs);
+
+ for (TInt i = 0; i < numVowelSeqs; i++)
+ {
+ if (vowelSeqs[i].iChars[0] == aChar ||
+ vowelSeqs[i].iChars[1] == aChar)
+ {
+ return vowelSeqs[i].iFirst;
+ }
+ }
+
+ return EPtiKeyNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::VietnameseToneMark
+//
+// ---------------------------------------------------------------------------
+//
+TUint16 CPtiQwertyKeyMappings::VietnameseToneMark(TUint16 aPrevChar, TPtiKey aKey)
+ {
+ __ASSERT_DEBUG(iExtension, User::Panic(KPtiNoExtensionPanic, KErrCorrupt));
+
+ TPtrC keyData = DataForKeyLocal((TPtiKey)aKey, EPtiCaseUpper, EPtiEngineQwerty);
+
+ if( keyData.Length() > 0 )
+ {
+ TChar data = keyData[0];
+ aKey = (TPtiKey)(TUint)data;
+ }
+
+ TInt toneIndex = 0;
+
+ for (; toneIndex < KNumVietnameseToneMarks; toneIndex++)
+ {
+ if (aKey == vietnameseToneMarkKeys[toneIndex])
+ {
+ if (aKey == (TPtiKey)iExtension->iLastTone)
+ {
+ return 0;
+ }
+ break;
+ }
+ }
+
+ if (toneIndex >= KNumVietnameseToneMarks)
+ {
+ return 0;
+ }
+
+ for (TInt i = 0; i < KNumVietnameseToneMarkDataEntries; i++)
+ {
+ if (vietnameseToneMarkData[i].iBaseChar == aPrevChar)
+ {
+ iExtension->iLastTone = (TInt16)aKey;
+ return vietnameseToneMarkData[i].iToneData[toneIndex];
+ }
+ }
+
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::GetAll
+//
+// ---------------------------------------------------------------------------
+//
+TPtrC CPtiQwertyKeyMappings::GetAll(TPtiTextCase aCase)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TPtrC keyData = DataForKeyLocal((TPtiKey)iCurrentKey, aCase, EPtiEngineQwerty);
+ if (keyData.Length() >= 1)
+ {
+ // return all characters excluding the marker character.
+ return TPtrC(keyData.Mid(1));
+ }
+
+ return TPtrC();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::GetNumericModeKeysFromDataL
+//
+// ---------------------------------------------------------------------------
+//
+void CPtiQwertyKeyMappings::GetNumericModeKeysFromDataL(RArray<TPtiNumericKeyBinding>& aResult)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TInt numEntries = 0;
+ const TPtiNumericKeyBinding* dataEntries = iKeyMapData->NumericModeKeysTable(iKeyboardType,
+ numEntries);
+
+ for (TInt i = 0; i < numEntries; i++)
+ {
+ User::LeaveIfError(aResult.Append(dataEntries[i]));
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::WriteData (DEPRECATED)
+//
+// ---------------------------------------------------------------------------
+//
+TInt CPtiQwertyKeyMappings::WriteData(TInt16*)
+ {
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::ChunkDataSize (DEPRECATED)
+//
+// ---------------------------------------------------------------------------
+//
+TInt CPtiQwertyKeyMappings::ChunkDataSize() const
+ {
+ return 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::SetKeyboardType
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPtiQwertyKeyMappings::SetKeyboardType(TPtiKeyboardType aKeyboardType)
+ {
+ __ASSERT_DEBUG(iKeyMapData, User::Panic(KPtiNoQwertyKeyMapDataPanic, KErrCorrupt));
+
+ TInt sizeTmp = 0;
+ if (!iKeyMapData->KeyData(aKeyboardType, sizeTmp))
+ {
+ return KErrNotSupported;
+ }
+
+ iKeyboardType = aKeyboardType;
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPtiQwertyKeyMappings::HasDataBlockForKeyboardType
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CPtiQwertyKeyMappings::HasDataBlockForKeyboardType(TPtiKeyboardType aKeyboardType) const
+ {
+ TInt sizeTmp = 0;
+ if (iKeyMapData->KeyData(aKeyboardType, sizeTmp))
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// End of file