/*

* 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 "cpcskeymap.h"

#if defined(USE_ORBIT_KEYMAP)

// If defined, only the currently used language's keymap is used

#include <QLocale>

#include <hbinputlanguage.h>

#include <hbinputkeymap.h>

#include <hbinputkeymapfactory.h>

#endif // #if defined(USE_ORBIT_KEYMAP)

#if defined(_DEBUG)

#include <e32debug.h> // RDebug

#define PRINT(x)			RDebug::Print(x)

#define PRINT1(x,y)			RDebug::Print(x,y)

#define PRINT2(x,y,z)		RDebug::Print(x,y,z)

#define PRINT3(w,x,y,z)		RDebug::Print(w,x,y,z)

#else // #if defined(_DEBUG)

#define PRINT(x)            

#define PRINT1(x,y)         

#define PRINT2(x,y,z)       

#define PRINT3(w,x,y,z)

#endif // #if defined(_DEBUG)

#define KSpaceChar      ' '

#if defined(USE_ORBIT_KEYMAP)

#define KSeparatorChar  ' '

#endif // #if defined(USE_ORBIT_KEYMAP)

// Separator character stored in predictive search table columns

_LIT(KSeparator, " ");

#if defined(USE_ORBIT_KEYMAP)

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

    };

#endif // #if defined(USE_ORBIT_KEYMAP)

// ============================== MEMBER FUNCTIONS ============================

// ----------------------------------------------------------------------------

// CPcsKeyMap::NewL

// ----------------------------------------------------------------------------

CPcsKeyMap* CPcsKeyMap::NewL()

	{

    self->ConstructL();

    return self;

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::~CPcsKeyMap

// ----------------------------------------------------------------------------

CPcsKeyMap::~CPcsKeyMap()

    {

    }

// ----------------------------------------------------------------------------

// CPcsKeyMap::GetNumericKeyStringL

// If aPlainConversion is EFalse, supports sub-string searches and space is

// converted to a separator character (not zero).

// ----------------------------------------------------------------------------

HBufC* CPcsKeyMap::GetNumericKeyStringL(const TDesC& aSource,

                                        TBool aPlainConversion) const

    {

    TInt length = aSource.Length();

    HBufC* destination = HBufC::NewL(length);

    TPtr ptr = destination->Des();

    for (TInt i = 0; i < aSource.Length(); ++i)

        {

        if (!aPlainConversion && aSource[i] == KSpaceChar)

            {

            ptr.Append(KSeparator);

            }

        else

            {

#if defined(USE_ORBIT_KEYMAP)

            ptr.Append(KeyForCharacter(aSource[i]));

#else

			TChar a = aSource[i];

			TChar b = a.GetUpperCase();

			ptr.Append(GetNumericValueForChar(b));

#endif

            }

        }

    return destination;

    }

#if defined(USE_ORBIT_KEYMAP)

// ----------------------------------------------------------------------------

// CPcsKeyMap::Separator

// ----------------------------------------------------------------------------

QChar CPcsKeyMap::Separator() const

    {

    return KSeparatorChar;

    }

// ----------------------------------------------------------------------------

// CPcsKeyMap::CPcsKeyMap

// Fill QList with empty strings

// ----------------------------------------------------------------------------

CPcsKeyMap::CPcsKeyMap() :

    iKeyMapping() 

	{

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::ConstructL

// ----------------------------------------------------------------------------

void CPcsKeyMap::ConstructL()

	{

	TInt err(KErrNone);

    if (err != KErrNone)

        {

        PRINT1(_L("ContructKeyboardMappings threw exception, err=%d"), err);

        User::Leave(err);

        }

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::ContructKeyboardMappings

// Fetch keymap for every language/country pair present.

// ----------------------------------------------------------------------------

	{

#if defined(_DEBUG)

    TInt count(0);

#endif

    QList<HbInputLanguage> languages;

#if defined(USE_ONLY_DEFAULT_LANG_KEYMAP)

	HbInputLanguage inputLanguage(QLocale::system().language()); 

	languages << inputLanguage;

#else

    languages = AvailableLanguages();

#endif

		{

		if (IsLanguageSupported(languages[lang].language()))

			{

				   languages[lang].language(),

			const HbKeymap* keymap =

				HbKeymapFactory::instance()->keymap(languages[lang].language(),

                                                    languages[lang].variant());

			if (keymap)

			    {

                    {

                    const HbMappedKey* mappedKey = keymap->keyForIndex(HbKeyboardVirtual12Key, key);

                        {

#if defined(_DEBUG)

#endif

                    }

			    }

			else

                {

                PRINT(_L("CPcsKeyMap::ContructKeyboardMapping keymap not found"));

                }

			}

		}

#if defined(_DEBUG)

#endif

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::AvailableLanguages

// Put default language at the beginning of the language list, so that

// ContructKeyboardMappingsL handles it first. 

// ----------------------------------------------------------------------------

QList<HbInputLanguage> CPcsKeyMap::AvailableLanguages() const

    {

	QList<HbInputLanguage> languages = HbKeymapFactory::availableLanguages();

	  // list of available languages. But since there is resource leak, the code

	  // is currently commented out until the leak is fixed.

	QLocale::Language currentLanguage = QLocale::system().language();

    if (!IsLanguageSupported(currentLanguage))

        {

        currentLanguage = QLocale::English;

        }

    HbInputLanguage defaultLanguage(currentLanguage);    

    if (languages.contains(defaultLanguage))

        {

        languages.removeOne(defaultLanguage);

        }

    languages.prepend(defaultLanguage); // THIS LEAKS RESOURCES!

#endif

    return languages;

    }

// ----------------------------------------------------------------------------

// CPcsKeyMap::IsLanguageSupported

// ----------------------------------------------------------------------------

TBool CPcsKeyMap::IsLanguageSupported(QLocale::Language aLanguage) const

	{

	return (aLanguage != QLocale::Japanese && aLanguage != QLocale::Chinese);

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::KeyForCharacter

// Loop all QStrings of iKeyMapping to find one containing the character.

// If the character is not mapped, use the character itself.

// ----------------------------------------------------------------------------

TChar CPcsKeyMap::KeyForCharacter(const TChar& aChar) const

    TUint charValue(aChar);

    QChar ch(charValue);

        {

        if (iKeyMapping[index].contains(ch))

            {

            return ArrayIndexToNumberChar(index);

            }

        }

    }

// ----------------------------------------------------------------------------

// CPcsKeyMap::KeyIdToNumber

// Map Orbit API's key id to the number that the key results when pressed. 

// ----------------------------------------------------------------------------

TInt CPcsKeyMap::KeyIdToNumber(TInt aKeyId) const

	{

	switch (aKeyId)

		{

		case EKey1:

		case EKey2:

		case EKey3:

		case EKey4:

		case EKey5:

		case EKey6:

		case EKey7:

		case EKey8:

		case EKey9:

			return aKeyId + 1;

		case EKey0:

			return 0;

		default:

			User::Panic(_L("CPcsKeyMap::KeyIdToNumber"), KErrArgument);

			return 0;

		}

	}

// ----------------------------------------------------------------------------

// CPcsKeyMap::ArrayIndexToNumberChar

// Map index of iKeyMapping list, to the number char that the mapping is for.

// ----------------------------------------------------------------------------

TChar CPcsKeyMap::ArrayIndexToNumberChar(TInt aArrayIndex) const

	{

	__ASSERT_DEBUG(aArrayIndex < KAmountOfKeys,

				   User::Panic(_L("CPcsKeyMap::ArrayIndexToNumberChar"),

				   KErrOverflow));

		{

		}

	}

#else // #if defined(USE_ORBIT_KEYMAP)

CPcsKeyMap::CPcsKeyMap()

	{

	}

void CPcsKeyMap::ConstructL()

	}

    {

	TChar ret = '0';

    switch (input)

        {

        case 'A': 

        case 'B': 

        case 'C':

        case 'D': 

        case 'E':

        case 'F':

            ret = '3';

            break;

        case 'G': 

        case 'H':

        case 'I':

            ret = '4';

            break;

        case 'J': 

        case 'K': 

        case 'L':

            ret = '5';

            break;

        case 'M': 

        case 'N': 

        case 'O':

            ret = '6';

            break;

        case 'P': 

        case 'Q':

        case 'R': 

        case 'S':

            ret = '7';

            break;

        case 'T':

        case 'U': 

        case 'V':

            ret = '8';

            break;

        case 'W':

        case 'X':

        case 'Y': 

        case 'Z':

            ret = '9';

            break;

        }

    return ret;    

    }

#endif // #if defined(USE_ORBIT_KEYMAP)

// End of file