/*
* Copyright (c) 2010 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: Retrieves the character map for each of the numeric keys.
*/
// INCLUDE FILES
#include "c12keykeymap.h"
#include "predictivesearchlog.h"
// Detection for Thai language is needed for both hardcoded and Orbit keymaps
#include <QTextCodec>
#include <hbinputkeymapfactory.h>
//#include <hbinputsettingproxy.h>
// How many keys have mappings in ITU-T keypad (keys 0..9, * and # have mappings)
const TInt KAmountOfKeys = 12;
// Largest amount of keypresses that can be stored in 12-key keyboard's
// predictive search tables.
// SQL BIGINT is a 64-bit signed integer, one bit is reserved for sign.
// 12-key keyboard's keys are identified by TKeyId that needs 4 bits.
// 63 / 4 = 15
const TInt KMaxKeysStoredInDb = 15;
// The first key of the keyboard has value zero ('1' in the 12-key virtual keypad)
enum TKeyId
{
EKey1 = 0,
EKey2,
EKey3,
EKey4,
EKey5,
EKey6,
EKey7,
EKey8,
EKey9,
EKey0,
EKeyStar,
EKeyHash
};
#if defined(USE_ORBIT_KEYMAP)
const QChar KStar = '*';
const QChar KPlus = '+';
const QChar KHash = '#';
#endif // #if defined(USE_ORBIT_KEYMAP)
// * key is mapped to this
const QChar KMappedCharForStar = 'a';
// # key is mapped to this
const QChar KMappedCharForHash = 'b';
// Unmapped (unknown) characters are replaced with this
const QChar KPadChar = 'f';
const QChar KLowerLimitPadding = '0';
const QChar KUpperLimitPadding = 'f';
const int KLatin1 = 4; // ISO_8859-1
const int KThaiLanguage = 2259; // Thai Industrial Standards Institute
// ============================== MEMBER FUNCTIONS ============================
// ----------------------------------------------------------------------------
// C12keyKeyMap::NewL
// ----------------------------------------------------------------------------
C12keyKeyMap* C12keyKeyMap::NewL()
{
PRINT(_L("Enter C12keyKeyMap::NewL"));
C12keyKeyMap* self = new (ELeave) C12keyKeyMap();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
PRINT(_L("End C12keyKeyMap::NewL"));
return self;
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::~C12keyKeyMap
// QTextCodec's destructor is protected, so it is not intended to be deleted.
// ----------------------------------------------------------------------------
C12keyKeyMap::~C12keyKeyMap()
{
PRINT(_L("Enter C12keyKeyMap::~C12keyKeyMap"));
PRINT(_L("End C12keyKeyMap::~C12keyKeyMap"));
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::ArrayIndexToMappedChar
// Map index of iKeyMapping list, to the number char that the mapping is for.
// ----------------------------------------------------------------------------
const QChar C12keyKeyMap::ArrayIndexToMappedChar(TInt aArrayIndex) const
{
__ASSERT_DEBUG(aArrayIndex < KAmountOfKeys,
User::Panic(_L("C12keyKeyMap::ArrayIndexToMappedChar"),
KErrOverflow));
switch (aArrayIndex)
{
case EKey0:
return '0';
case EKeyStar:
return KMappedCharForStar;
case EKeyHash:
return KMappedCharForHash;
default:
return aArrayIndex + '1';
}
}
#if !defined(USE_ORBIT_KEYMAP)
// ----------------------------------------------------------------------------
// C12keyKeyMap::UseHardcodedKeyMap
// ----------------------------------------------------------------------------
QChar C12keyKeyMap::UseHardcodedKeyMap(QChar input) const
{
QChar ret = '0';
switch (input.unicode())
{
#if defined(THAI_KEYMAP)
case 0x21B2:
ret = '0';
break;
case 0x0E01:
case 0x0E02:
case 0x0E03:
case 0x0E04:
case 0x0E05:
#endif
case '-':
case '?':
ret = '1';
break;
case 'a':
case 'A':
case 'b':
case 'B':
case 'c':
case 'C':
#if defined(THAI_KEYMAP)
case 0x0E06:
case 0x0E07:
case 0x0E08:
case 0x0E09:
#endif
ret = '2';
break;
case 'd':
case 'D':
case 'e':
case 'E':
case 'f':
case 'F':
#if defined(THAI_KEYMAP)
case 0x0E0A:
case 0x0E0B:
case 0x0E0C:
case 0x0E0D:
#endif
ret = '3';
break;
case 'g':
case 'G':
case 'h':
case 'H':
case 'i':
case 'I':
#if defined(THAI_KEYMAP)
case 0x0E0E:
case 0x0E0F:
case 0x0E10:
case 0x0E11:
case 0x0E12:
case 0x0E13:
#endif
ret = '4';
break;
case 'j':
case 'J':
case 'k':
case 'K':
case 'l':
case 'L':
#if defined(THAI_KEYMAP)
case 0x0E14:
case 0x0E15:
case 0x0E16:
case 0x0E17:
case 0x0E18:
#endif
ret = '5';
break;
case 'm':
case 'M':
case 'n':
case 'N':
case 'o':
case 'O':
#if defined(THAI_KEYMAP)
case 0x0E19:
case 0x0E1A:
case 0x0E1B:
case 0x0E1C:
case 0x0E1D:
#endif
ret = '6';
break;
case 'p':
case 'P':
case 'q':
case 'Q':
case 'r':
case 'R':
case 's':
case 'S':
#if defined(THAI_KEYMAP)
case 0x0E1E:
case 0x0E1F:
case 0x0E20:
case 0x0E21:
case 0x0E22:
#endif
ret = '7';
break;
case 't':
case 'T':
case 'u':
case 'U':
case 'v':
case 'V':
#if defined(THAI_KEYMAP)
case 0x0E23:
case 0x0E24:
case 0x0E25:
case 0x0E26:
case 0x0E27:
case 0x0E28:
case 0x0E29:
#endif
ret = '8';
break;
case 'w':
case 'W':
case 'X':
case 'x':
case 'Y':
case 'y':
case 'z':
case 'Z':
#if defined(THAI_KEYMAP)
case 0x0E2A:
case 0x0E2B:
case 0x0E2C:
case 0x0E2D:
case 0x0E2E:
#endif
ret = '9';
break;
case '*':
case '+':
#if defined(THAI_KEYMAP)
case 0x0E2F:
case 0x0E3F:
case 0x0E31:
case 0x0E34:
case 0x0E35:
case 0x0E36:
case 0x0E37:
case 0x0E38:
case 0x0E39:
case 0x0E46:
case 0x0E47:
case 0x0E48:
case 0x0E49:
case 0x0E4A:
case 0x0E4B:
case 0x0E4C:
#endif
ret = KMappedCharForStar;
break;
case '#':
#if defined(THAI_KEYMAP)
case 0x0E30:
case 0x0E32:
case 0x0E33:
case 0x0E40:
case 0x0E41:
case 0x0E42:
case 0x0E43:
case 0x0E44:
#endif
ret = KMappedCharForHash;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case ' ':
ret = input; // Numbers and space
break;
default: // Other (unknown) chars
ret = KPadChar;
}
return ret;
}
#endif // #if !defined(USE_ORBIT_KEYMAP)
// ----------------------------------------------------------------------------
// C12keyKeyMap::ComputeValue
// ----------------------------------------------------------------------------
TInt C12keyKeyMap::ComputeValue(QString aString,
TBool aUpperLimit,
QString& aValue) const
{
QString hexString;
if (aString.length() < KMaxKeysStoredInDb)
{
QChar pad = KLowerLimitPadding;
if (aUpperLimit)
{
pad = KUpperLimitPadding;
}
hexString = aString.leftJustified(KMaxKeysStoredInDb, pad);
}
else
{
hexString = aString;
}
const TInt KHexadecimalBase = 16;
bool ok(true);
// Use signed int to prevent underflow when padded is "00...00"
qint64 value = hexString.toLongLong(&ok, KHexadecimalBase);
if (!ok)
{
PRINT(_L("CPcsKeyMap::ComputeValue fails"));
return KErrArgument;
}
// In order to write queries using '>' and '<' instead of '>=' and '<=',
// expand the limit by one.
if (aUpperLimit)
{
++value;
}
else
{
--value;
}
aValue = QString::number(value); // Convert to decimal value
return KErrNone;
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::SetHardcodedCharacters
// In emulator (except in unit tests), select just the default language, as new
// SDKs have over 40 languages, causing out of memory error.
// In hardware and when compiling unit tests in emulator, select all languages
// available in the device. Reason: it is though that HW does not come with
// dozens of languages and some unit test cases require Thai keymap.
// ----------------------------------------------------------------------------
QList<HbInputLanguage> C12keyKeyMap::SelectLanguages()
{
#if defined(__WINSCW__) && !defined(EUNIT_UNIT_TEST_COVERAGE)
return CPcsKeyMap::SelectLanguages();
#else
return HbKeymapFactory::availableLanguages();
#endif
}
#if defined(USE_ORBIT_KEYMAP)
// ----------------------------------------------------------------------------
// C12keyKeyMap::SetHardcodedCharacters
// Even though most languages map *, + and # to 1-key, they are here mapped to
// the distinct *-key or #-key of the 12-key ITU-T keypad.
// ----------------------------------------------------------------------------
void C12keyKeyMap::SetHardcodedCharacters()
{
iKeyMapping[EKeyStar].append(KStar);
iKeyMapping[EKeyStar].append(KPlus);
iKeyMapping[EKeyHash].append(KHash);
iHardcodedChars.append(KStar);
iHardcodedChars.append(KPlus);
iHardcodedChars.append(KHash);
}
#endif // #if defined(USE_ORBIT_KEYMAP)
// ----------------------------------------------------------------------------
// C12keyKeyMap::DetermineSpecialCharBehaviour
// If input string is Thai language, skip chars that map to star or hash keys.
// ----------------------------------------------------------------------------
TBool C12keyKeyMap::DetermineSpecialCharBehaviour(QString aSource) const
{
/* this code would use the current input language to determine if Thai is in use
HbInputLanguage lang = HbInputSettingProxy::instance()->globalInputLanguage();
TBool skipHashStar = lang.language() == QLocale::Thai; */
if (iLatinCodec && iLatinCodec->canEncode(aSource))
{
return EFalse;
}
return iThaiCodec && iThaiCodec->canEncode(aSource);
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::ShouldSkipChar
// Characters mapped to certain keys (*,#) are skipped for certain languages.
// ----------------------------------------------------------------------------
TBool C12keyKeyMap::ShouldSkipChar(QChar aChar, TBool aSkipHashStar) const
{
return aSkipHashStar &&
(aChar == KMappedCharForStar || aChar == KMappedCharForHash);
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::C12keyKeyMap
// Fill QList with empty strings
// ----------------------------------------------------------------------------
C12keyKeyMap::C12keyKeyMap() :
CPcsKeyMap(KAmountOfKeys, KPadChar, KMaxKeysStoredInDb)
{
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::ConstructL
// ----------------------------------------------------------------------------
void C12keyKeyMap::ConstructL()
{
PRINT(_L("Enter C12keyKeyMap::ConstructL"));
#if defined(USE_ORBIT_KEYMAP)
CPcsKeyMap::ConstructL(HbKeyboardVirtual12Key);
#else
CPcsKeyMap::ConstructL();
#endif
TInt err(KErrNone);
QT_TRYCATCH_ERROR(err, GetTextCodecs());
if (err != KErrNone)
{
PRINT1(_L("C12keyKeyMap::ConstructL exception, err=%d"), err);
User::Leave(err);
}
PRINT(_L("End C12keyKeyMap::ConstructL"));
}
// ----------------------------------------------------------------------------
// C12keyKeyMap::GetTextCodecs
// ----------------------------------------------------------------------------
void C12keyKeyMap::GetTextCodecs()
{
iLatinCodec = QTextCodec::codecForMib(KLatin1);
iThaiCodec = QTextCodec::codecForMib(KThaiLanguage);
}
// End of file