/*

* Copyright (c) 2008 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:  Keymappings etc. customized for Series 60.

*

*/

// INCLUDE FILES

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <CVPbkContactManager.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <CPbk2SortOrderManager.h>

#include <Pbk2ContactNameFormatterFactory.h>

#include <MPbk2ContactNameFormatter.h>

// Avkon dialog for info notes

#include <aknnotewrappers.h>

// for fetching contacts from phonebook

#include <CPbk2StoreConfiguration.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactStoreList.h>

#include <CVPbkContactManager.h>

// aiw used to invoke phonebook

#include <AiwContactSelectionDataTypes.h>

// phone client API classes for starting phone call

#include <AiwCommon.h>

#include <aiwdialdata.h>

#include <aiwdialdataext.h>

// FeatureManager::FeatureSupported(KFeatureIdThai) used in SetInitialInputModeL

#include <featmgr.h>

// CAknExtendedInputCapabilities for extended input capabilities

#include <aknextendedinputcapabilities.h>

#include <StringLoader.h>

#include <eikenv.h>

#include <eikappui.h>

#include <coecntrl.h>

#include <EIKCOCTL.rsg>

#include <aknenv.h>

#include <AknUtils.h>

#include <AknSettingCache.h>

#include <aknappui.h>

#include <AknsUtils.h>

#include <j2me/jdebug.h>

#include "CMIDKeyDecoder.h"

#include "CMIDEdwinUtils.h"

#include <lcdui.rsg>

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDEdwin.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

CMIDEdwinUtils* CMIDEdwinUtils::NewL(MMIDTextBox* aTextBox, const TChar aDecimalSeparator)

{

    CMIDEdwinUtils* utils = new(ELeave) CMIDEdwinUtils(aTextBox, aDecimalSeparator);

    CleanupStack::PushL(utils);

    utils->ConstructL();

    CleanupStack::Pop(utils);

    return utils;

}

CMIDEdwinUtils::CMIDEdwinUtils(MMIDTextBox* aTextBox, const TChar aDecimalSeparator)

        : iTextBox(aTextBox), iDecimalSeparator(aDecimalSeparator)

{}

void CMIDEdwinUtils::ConstructL()

{

}

/**

 * Checks whether the given text is valid within the given constraints.

 * When the contents of the TextBox are set PROGRAMMATICALLY (parameter aActualContents

 * is true), constraint validity is checked more strictly, as some constraints

 * allow certain strings while the user is typing but not as the actual contents.

 */

TBool CMIDEdwinUtils::ConstraintsValidForText(const TDesC& aText,TUint aConstraints, TBool aActualContents)

{

    TUint constraint = aConstraints & MMIDTextField::EConstraintMask;

    if (constraint == MMIDTextField::EAny)

        return ETrue;

    //

    TBool valid = ETrue;

    switch (constraint)

    {

    case MMIDTextField::EMailAddr:

    case MMIDTextField::EUrl:

        valid = IsTextValid(aText);

        break;

    case MMIDTextField::ENumeric:

        if (aActualContents)

        {

            valid = IsJavaInteger(aText);

        }

        else

        {

            valid = IsNumeric(aText);

        }

        break;

    case MMIDTextField::EPhoneNumber:

        valid = CMIDEdwinUtils::IsPhoneNumber(aText);

        break;

    case MMIDTextField::EDecimal:

        if (aActualContents)

        {

            valid = IsJavaFloatingPointLiteral(aText);

        }

        else

        {

            valid = IsDecimal(aText, iDecimalSeparator);

        }

        break;

    default:

        ASSERT(EFalse);

    }

    return valid;

}

TBool CMIDEdwinUtils::ConstraintsValidForInsertedTextL(const TDesC& aText, const TDesC& aTextToInsert, TInt aPos, TUint aConstraints, TBool aActualContents)

{

    HBufC* text = HBufC::NewL(aText.Length() + aTextToInsert.Length());

    TPtr ptr = text->Des();

    ptr.Copy(aText);

    ptr.Insert(aPos,aTextToInsert);

    TBool valid = ConstraintsValidForText(ptr, aConstraints, aActualContents);

    delete text;

    return valid;

}

TBool CMIDEdwinUtils::IsHotKeyL(const TKeyEvent& aKeyEvent, CCoeEnv* aCoeEnv)

{

    TBuf<24> buf;

    if (aKeyEvent.iModifiers & EModifierShift)

    {

        aCoeEnv->ReadResourceL(buf,R_EIK_EDWIN_SHIFT_CTRL_HOTKEYS);

    }

    else

    {

        aCoeEnv->ReadResourceL(buf,R_EIK_EDWIN_CTRL_HOTKEYS);

    }

    const TInt ret=buf.Locate(TChar(aKeyEvent.iCode+'a'-1));

    switch (ret)

    {

    case CEikEdwin::EHotKeyCut:

    case CEikEdwin::EHotKeyCopy:

    case CEikEdwin::EHotKeyPaste:

    case CEikEdwin::EHotKeyUndo:

    case CEikEdwin::EHotKeyFind:

    case CEikEdwin::EHotKeyInsertChar:

        return ETrue;

    default:

        return EFalse;

    }

}

TBool CMIDEdwinUtils::IsNavigationKey(const TKeyEvent& aKeyEvent)

{

    switch (aKeyEvent.iCode)

    {

    case EKeyDownArrow:

    case EKeyUpArrow:

    case EKeyLeftArrow:

    case EKeyRightArrow:

    case EKeyBackspace:

    case EKeyDelete:

    case EKeyEscape:

    case EKeyPageUp:

    case EKeyPageDown:

    case EKeyHome:

    case EKeyEnd:

        return ETrue;

    default:

        return EFalse;

    }

}

TBool CMIDEdwinUtils::IsPhoneNumber(const TDesC& aText)

{

    TInt pos = aText.Length();

    for (; pos>0;)

    {

        TChar ch((aText)[--pos]);

        // allow also digits in non-western numbers

        if (IsNumeric(ch))

            continue;

        switch (ch)

        {

        case '+':

        case '*':

        case '#':

        case 'p':

        case 'w':

            break;

        default:

            return EFalse;

        }

    }

    return ETrue;

}

/**

 * Tests whether a typed string is a legal NUMERIC string. This test is more

 * loose than that in IsJavaInteger(), as "-" is a

 * legal text value during typing but not when set programmatically.

 */

TBool CMIDEdwinUtils::IsNumeric(const TDesC& aText)

{

    TInt length = aText.Length();

    TInt pos = length;

    for (; pos>0;)

    {

        TChar ch((aText)[--pos]);

        //

        if (IsNumeric(ch))

            continue;

        //

        switch (ch)

        {

        case '-':

            if (pos != 0)

                return EFalse;

            break;

        default:

            return EFalse;

        }

    }

    return ETrue;

}

/**

* Tests whether a character is legal number, correct values

* are 0-9 and all language variants (arabic etc.)

*/

TBool CMIDEdwinUtils::IsNumeric(const TChar& aChar)

{

    return ((aChar >= '0' && aChar <= '9')            // Western

            || (aChar >= 0x0660 && aChar <= 0x0669)  // Arabic-Indic

            || (aChar >= 0x06F0 && aChar <= 0x06F9)  // Extended Arabic-Indic

            || (aChar >= 0x0966 && aChar <= 0x096F)  // Devanagari

            || (aChar >= 0xFF10 && aChar <= 0xFF19)  // Fullwidth

           );

}

/**

 * Tests whether the given string is a legal NUMERIC string when set

 * programmatically.

 *

 * According to the Java API spec, a string cannot be parsed into an int if:

 * Any character of the string is not a digit of the specified radix,

 * except that the first character may be a minus sign '-' ('\u002D')

 * provided that the string is longer than length 1.

 */

TBool CMIDEdwinUtils::IsJavaInteger(const TDesC& aText)

{

    if (!IsNumeric(aText))

    {

        return EFalse;

    }

    // additional test #1: "-" is illegal

    if (aText.Length() == 1)

    {

        if ((aText.Locate(TChar('-')) == 0))

        {

            return EFalse;

        }

    }

    return ETrue;

}

/**

 * Tests whether a typed text is a valid one.

 */

TBool CMIDEdwinUtils::IsTextValid(const TDesC& aText)

{

    TInt pos = aText.Length();

    while (pos-- > 0)

    {

        TChar ch((aText)[ pos ]);

        // IsValidChar function will check chars over 255

        if (!IsValidChar(ch.GetNumericValue()) || ch == 0x7f)

        {

            return EFalse;

        }

    }

    return ETrue;

}

/**

 * Tests whether a char is a valid. Tests only characters over 255

 */

TBool CMIDEdwinUtils::IsValidChar(TInt aChar) const

{

    TBool ret(ETrue);

    // Tests only characters over 255

    if (aChar >= 0xFF)

    {

        // 0x20AC - Unicode for euro sign

        if (aChar == 0x20AC || aChar == CEditableText::EParagraphDelimiter ||

                aChar == CEditableText::ELineBreak)

        {

            ret = ETrue;

        }

        else

        {

            ret = EFalse;

        }

    }

    return ret;

}

/**

 * Tests whether a typed string is a legal DECIMAL string. This test is more

 * loose than that in IsJavaFloatingPointLiteral(), as ".", "-" and "-." are

 * legal text values during typing but not when set programmatically.

 */

TBool CMIDEdwinUtils::IsDecimal(const TDesC& aText, const TChar aDecimalSeparator)

{

    TInt length = aText.Length();

    TInt pos = length;

    for (; pos>0;)

    {

        TChar ch((aText)[--pos]);

        //

        if (ch.IsDigit())

        {

            continue;

        }

        else if (ch == '-')

        {

            if (pos != 0)

                return EFalse;

        }

        else if (ch == aDecimalSeparator)

        {

            if (aText.Locate(aDecimalSeparator) != aText.LocateReverse(aDecimalSeparator))

                return EFalse;

        }

        else

        {

            return EFalse;

        }

    }

    return ETrue;

}

/**

 * Tests whether the given string is a legal DECIMAL string when set

 * programmatically.

 */

TBool CMIDEdwinUtils::IsJavaFloatingPointLiteral(const TDesC& aText)

{

    if (!IsDecimal(aText, '.'))

    {

        return EFalse;

    }

    // additional test #1: "." and "-" are illegal

    if (aText.Length() == 1)

    {

        if ((aText.Locate(TChar('.')) == 0) || (aText.Locate(TChar('-')) == 0))

        {

            return EFalse;

        }

    }

    // additional test #2: "-." is illegal

    if (aText.Length() == 2)

    {

        if ((aText.Locate(TChar('-')) == 0) && (aText.Locate(TChar('.')) == 1))

        {

            return EFalse;

        }

    }

    return ETrue;

}

void CMIDEdwinUtils::RemoveNonPhoneNumberChars(HBufC* buf)

{

    TPtr text = buf->Des();

    for (TInt pos=0; pos < text.Length();)

    {

        TChar ch((text)[pos]);

        // allow also digits in non-western numbers

        if (IsNumeric(ch))

        {

            ++pos;

            continue;

        }

        switch (ch)

        {

        case '+':

        case '*':

        case '#':

        case 'p':

        case 'w':

            ++pos;

            continue;

        }

        text.Delete(pos, 1);

    }

}

/** Converts from java format text to localized (visible) format.

@see ConvertToLocalizedDecimalLC() */

HBufC* CMIDEdwinUtils::ConvertToLocalizedLC(const TDesC& aText, TUint aConstraints)

{

    HBufC* text = NULL;

    if ((aConstraints & MMIDTextField::EConstraintMask) == MMIDTextField::EDecimal)

    {

        text = ConvertToLocalizedDecimalLC(aText);

    }

    else

    {

        text = aText.AllocLC();

        TBool supportLineBreaks(ETrue);

        // Convert breaks if needed if constraints that do not allow line

        // breaks.

        if (aConstraints & MMIDTextField::EUrl ||

                aConstraints & MMIDTextField::EMailAddr)

        {

            // Line breaks are not supported

            supportLineBreaks = EFalse;

        }

        CMIDUtils::MapJavaToETextChars(text, supportLineBreaks);

    }

    return text;

}

/** Converts decimal point, if any, to a localized decimal separator. */

HBufC* CMIDEdwinUtils::ConvertToLocalizedDecimalLC(const TDesC& aText)

{

    HBufC* buf = aText.AllocLC();

    TPtr text = buf->Des();

    TInt pos = buf->Length();

    for (; pos>0;)

    {

        TText& ch = text[--pos];

        if (ch == '.')

            ch = (TText)iDecimalSeparator;

    }

    return buf;

}

/** Converts localized decimal separator, if any, to a decimal point. */

void CMIDEdwinUtils::ConvertFromLocalizedDecimal(HBufC* buf)

{

    TPtr text = buf->Des();

    TInt pos = buf->Length();

    for (; pos>0;)

    {

        TText& ch = text[--pos];

        if (ch == (TText)iDecimalSeparator)

            ch = '.';

    }

}

TLanguage CMIDEdwinUtils::SelectLanguage(TInt aCharSubset,

        TLanguage aDefaultLanguage)

{

    TLanguage language = CAknEnv::Static()->SettingCache().InputLanguage();

    if (IsLanguageInCharSubset(language, aCharSubset))

    {

        return language;        // global input language

    }

    language = User::Language();

    if (IsLanguageInCharSubset(language, aCharSubset))

    {

        return language;        // display language

    }

    return aDefaultLanguage;    // given default

}

/**

 * Returns ETrue if the given language belongs to the given MIDP character subset.

 */

TBool CMIDEdwinUtils::IsLanguageInCharSubset(TLanguage aLanguage, TInt aCharSubset)

{

    switch (aLanguage)

    {

        // Cyrillic languages:

    case ELangBulgarian:

    case ELangRussian:

    case ELangSerbian:

    case ELangUkrainian:

        return (aCharSubset == EMidpUcbCyrillic);

        // Arabic languages:

    case ELangArabic:

    case ELangFarsi:

    case ELangUrdu:

        return (aCharSubset == EMidpUcbArabic);