/*

* Copyright (c) 2007 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: Chinese Find Utilities implementation file.

*

*/

#include <PtiEngine.h>

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#include <aknedsts.h>

#include <coeaui.h>

#include <AvkonInternalCRKeys.h>

// The below code is commented out because current CFindUtilChineseECE is used

// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

// for the further merging work (merge from FindUtil 5.0)

#if 0

#include <aknenv.h> //phonebook

#include <aknappui.h>

#include <aknapp.h>

#include <eikenv.h>

#include <eikapp.h>

#include <eikappui.h>

#endif

#include "CPcsAlgorithm2.h"

#include "FindUtilChineseECE.h"

#include "chinesefindutils.h"

#include "CPcsKeyMap.h"

#include "CPsQuery.h"

#include "CPsQueryItem.h"

// CONSTANTS 

const TUint16 KStarChar = 0x002a;

const TUint16 KZhuyinstart = 0x3105;

const TInt KZhuyincount = 37;

const TInt KSeperator = 2626;

const TUint16 KMinUnicodeHz = 0x4e00;

const TUint16 KMaxUnicodeHz = 0x9fa5;

const TUint16 KStrokeHorizontalValue = 0x4e00;

const TUint16 KStrokeVerticalValue = 0x4e28;

const TUint16 KStrokeDownToLeftValue = 0x4e3f;

const TUint16 KStrokeDownToRightValue = 0x4e36;

const TUint16 KStrokeBendingValue = 0x4e5b;

const TInt KSysInputMode = -1;

const TInt KLeftToRightFlag =0x200e;

const TInt KRightToLeftFlag =0x200f;

// The below code is commented out because current CFindUtilChineseECE is used

// on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

// for the further merging work (merge from FindUtil 5.0)

#if 0

const TUid KUidPhoneBook = {0x101F4CCE};

const TUid KUidPhoneBookServer = {0x10207277};

#endif

_LIT(KWildChar, "*");

_LIT(KUnderLine, "_");

_LIT(KMiddleLine, "-");

_LIT(KBlank, " ");

_LIT(KTab, "\t");

_LIT(KPanicReason, "Abnormal input parameters!");

const TInt KLitLineFeed(8233);

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

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

// Symbian constructor

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

//

CFindUtilChineseECE* CFindUtilChineseECE::NewL(CPcsAlgorithm2* aAlgorithm)

    {

    CFindUtilChineseECE* self = new (ELeave) CFindUtilChineseECE();

    CleanupStack::PushL(self);

    self->ConstructL(aAlgorithm);

    CleanupStack::Pop(self);//self

    return self;

    }

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

// Symbian second-phase constructor

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

//

void CFindUtilChineseECE::ConstructL(CPcsAlgorithm2* aAlgorithm)

    {

    iRepositoryFind = CRepository::NewL(KCRUidAknFep);

    iRepositoryFindAdaptive = CRepository::NewL(KCRUidAvkon);

    iWatcher = CFindRepositoryWatcher::NewL(KCRUidAknFep, 

        TCallBack(HandleFindRepositoryCallBack, this), 

        iRepositoryFind);

    iWatcherAdaptive = CFindRepositoryWatcher::NewL(KCRUidAvkon,

        TCallBack(HandleFindRepositoryCallBack, this),

        iRepositoryFindAdaptive);

    iAlgorithm = aAlgorithm;

    OpenL();

    }

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

// CFindUtilChineseECE utils class

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

//

CFindUtilChineseECE::CFindUtilChineseECE() :

iLanguage(ELangTest),

iCurInputMode(KSysInputMode),

iSearchMethod(EAdptSearchPinyin),

iSearchMethodAdaptive(EFalse)

    {

    }

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

// Destructor

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

//

CFindUtilChineseECE::~CFindUtilChineseECE()

    {

    delete iPtiEngine;

    delete iWatcher;

    delete iRepositoryFind;

    delete iWatcherAdaptive;

    delete iRepositoryFindAdaptive;

    }

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

// Open ptiengine and active it by input language

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

//

TBool CFindUtilChineseECE::OpenT9InterfaceL(TLanguage aLanguage)

    {

    if (!iPtiEngine)

        {

        iPtiEngine = CPtiEngine::NewL();

        }

    if (aLanguage != iLanguage)

        {

        // We only support Chinese languages. If input language is changed

        // to non-Chinese, then first available Chinese language is used

        // instead.

        if ( aLanguage == ELangPrcChinese ||

             aLanguage == ELangTaiwanChinese ||

             aLanguage == ELangHongKongChinese )

            {

            iLanguage = aLanguage;

            }

        else if ( IsSupportLanguage(ELangPrcChinese) )

            {

            iLanguage = ELangPrcChinese;

            }

        else if ( IsSupportLanguage(ELangTaiwanChinese) )

            {

            iLanguage = ELangTaiwanChinese;

            }

        else if ( IsSupportLanguage(ELangHongKongChinese) )

            {

            iLanguage = ELangHongKongChinese;

            }

        else

            {

            iLanguage = aLanguage;

            }

        iPtiEngine->ActivateLanguageL(iLanguage);

        iPtiEngine->EnableToneMarks(EFalse);

        }

    return ETrue;

    }

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

// Close ptiengine

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

//

void CFindUtilChineseECE::CloseT9InterfaceL()

    {

    iLanguage = ELangTest;

    iPtiEngine->CloseCurrentLanguageL();

    }

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

// Translate Chinese word to its spelling

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

//

TBool CFindUtilChineseECE::DoTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList)

    {

    // Always translate according the adaptive search method setting

    return T9ChineseTranslationAdaptiveL(aHZUnicode, aSpellList);

#if 0

    // The below code is commented out because current CFindUtilChineseECE is used

    // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

    // for the further merging work (merge from FindUtil 5.0)

#if 0

    if(CEikonEnv::Static())

        {

        if (iSearchMethodAdaptive &&(CEikonEnv::Static()->EikAppUi()->Application()->AppDllUid() == KUidPhoneBook ||

            CEikonEnv::Static()->EikAppUi()->Application()->AppDllUid() == KUidPhoneBookServer ))

            {

            if (!T9ChineseTranslationAdaptiveL(aHZUnicode, aSpellList))

                {

                return EFalse;

                }    

            }

        else

            {

#endif

            if (!T9ChineseTranslationL(aHZUnicode, aSpellList))

                {

                return EFalse;

                }

            // The below code is commented out because current CFindUtilChineseECE is used

            // on 3.2.3 which is not supported adaptive search. It will be easy to keep these code 

            // for the further merging work (merge from FindUtil 5.0)

#if 0          

            }

        }

    else

        {

        if (iSearchMethodAdaptive)

            {

            if (!T9ChineseTranslationAdaptiveL(aHZUnicode, aSpellList))

                {

                return EFalse;

                }

            }

        else

            {

            if (!T9ChineseTranslationL(aHZUnicode, aSpellList))

                {

                return EFalse;

                }

            }

        }

#endif

    return ETrue;

#endif

    }

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

// Find pane text is including stroke symbol

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

//

TInt CFindUtilChineseECE::IsStrokeSymbol(const TUint16 aFindWord)

    {

    TInt strokeValue = 0;

    switch (aFindWord)

        {

        case KStrokeHorizontalValue:

            strokeValue = 1;

            break;

        case KStrokeVerticalValue:

            strokeValue = 2;

            break;

        case KStrokeDownToLeftValue:

            strokeValue = 3;

            break;

        case KStrokeDownToRightValue:

            strokeValue = 4;

            break;

        case KStrokeBendingValue:

            strokeValue = 5;

            break;

        default:

            return strokeValue;

        }// switch

    return strokeValue;

    }

#if 0

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

// Do translate for Chinese word

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

//

TBool CFindUtilChineseECE::T9ChineseTranslationL(TInt16 aHZUnicode, RPointerArray<HBufC>& aSpellList)

    {

    TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;

    if (iLanguage == ELangPrcChinese)

        {

        if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin) != KErrNone)

            {

            return EFalse;

            }

        }

    else if (iLanguage == ELangTaiwanChinese)

        {

        if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiZhuyin) != KErrNone)

            {

            return EFalse;

            }

        }

    else if (iLanguage == ELangHongKongChinese)

        {

        if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes) != KErrNone)

            {

            return EFalse;

            }

        }

    else if (iLanguage == ELangEnglish)

        {

        if (!iSupportPRCChinese)

            {

            return EFalse;

            }

        TInt err = KErrNone;

        if (!iPtiEnginePrc)

            {

            iPtiEnginePrc = CPtiEngine::NewL(EFalse);

            TRAP(err, iPtiEnginePrc->ActivateLanguageL(ELangPrcChinese));

            }

        if (err == KErrNone)

            {

            if (iPtiEnginePrc->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin) != KErrNone)

                {

                return EFalse;

                }

            }

        }

    else

        {

        return EFalse;

        }

    const TInt len = wordInterpretationBuf.Length();

    TInt start = 0;

    for (TInt i = 0; i < len; i++)

        {

        if (wordInterpretationBuf[i] == KSeperator)

            {

            aSpellList.Append((wordInterpretationBuf.MidTPtr(start, i - start)).Alloc());

            start = i + 1;

            }

        }

    aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len - start)).Alloc());

    return ETrue;

    }

#endif

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

// Do translate for Chinese word

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

//

TBool CFindUtilChineseECE::T9ChineseTranslationAdaptiveL(TInt16 aHZUnicode,  

    RPointerArray<HBufC>& aSpellList)

    {

    TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;

    switch(iSearchMethod)

        {

        case EAdptSearchPinyin:

            if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiPinyin)

                != KErrNone)

                {

                return EFalse;

                }

             break;

        case EAdptSearchStroke:

            if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiStrokes)

                != KErrNone)

                {

                return EFalse;

                }

            break;

        case EAdptSearchZhuyin:

            if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiZhuyin)

                != KErrNone)

                {

                return EFalse;

                }   

            break;

        case EAdptSearchNormalCangjie:

            if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie)

                != KErrNone)

                {

                return EFalse;

                }

            break;

        case EAdptSearchEasyCangjie:

            if (iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie) 

                != KErrNone)

                {

                return EFalse;

                }

            break;

        case EAdptSearchAdvCangjie:

            if ((iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie) != KErrNone)

                &&(iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie) != KErrNone))

                {

                return EFalse;

                }

            break;

        default:

            return EFalse;

        }

    TInt len = wordInterpretationBuf.Length();

    TInt start = 0;

    if( iSearchMethod != EAdptSearchAdvCangjie )

        {

        for (TInt i =0; i < len; i++)

            {

            if (wordInterpretationBuf[i] == KSeperator) 

                {

                aSpellList.Append((wordInterpretationBuf.MidTPtr(start, i-start)).Alloc());

                start = i + 1;

                }

            }

        aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len-start)).Alloc());

        }

    //Could look advanced cangjie as normal and easy cangjie

    else 

        {

        iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiEasyCangjie);

        len = wordInterpretationBuf.Length();

        start = 0;

        for (TInt i =0; i < len; i++)

            {

            if (wordInterpretationBuf[i] == KSeperator) 

                {

                aSpellList.Append((wordInterpretationBuf.MidTPtr(start, i-start)).Alloc());

                start = i + 1;

                }

            }

        aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len-start)).Alloc()); 

        iPtiEngine->GetSpelling(aHZUnicode, wordInterpretationBuf, EPtiCangJie);

        len = wordInterpretationBuf.Length();

        start = 0;

        for (TInt i =0; i < len; i++)

            {

            if (wordInterpretationBuf[i] == KSeperator) 

                {

                aSpellList.Append((wordInterpretationBuf.MidTPtr(start, i-start)).Alloc());

                start = i + 1;

                }

            }

        aSpellList.Append((wordInterpretationBuf.MidTPtr(start, len-start)).Alloc());  

        }

    return ETrue;

    }

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

// Find pane text is including separator

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

//

TBool CFindUtilChineseECE::IsFindWordSeparator(TChar aCh)

    {

    return aCh ==' '|| aCh=='-'|| aCh =='\t' || aCh == '_'|| aCh == KLitLineFeed;

    }

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

// Create ptiengine and initialize member data 

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

//

void CFindUtilChineseECE::OpenL()

    {

    TInt inputLanguage = 0;

    TInt searchMode = 0;

    if (iRepositoryFind != NULL)

        {

        iRepositoryFind->Get(KAknFepInputTxtLang, inputLanguage);

        }

    // The following sets iLangueage to inputLanguage if inputLanguage

    // is Chinese. If inputLanguage is non-Chinese, iLanguage will be

    // set to first available Chinese language.

    OpenT9InterfaceL((TLanguage) inputLanguage);

    if (iRepositoryFindAdaptive != NULL)

        {

        iRepositoryFindAdaptive->Get(KAknAvkonAdaptiveSearchEnabled, iSearchMethodAdaptive);

        }

    if (iLanguage == ELangPrcChinese)

        {

        iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChinesePRC , searchMode);

        if (searchMode == 0)

            {

            iSearchMethod = EAdptSearchPinyin;

            }

        else if (searchMode == 1)

            {

            iSearchMethod = EAdptSearchStroke;

            }

        }

    else if (iLanguage == ELangTaiwanChinese)

        {

        iRepositoryFindAdaptive->Get(KAknAdaptiveSearchChineseTW , searchMode);

        if (searchMode == 0)

            {

            iSearchMethod = EAdptSearchZhuyin;

            }

        else if (searchMode == 1)

            {

            iSearchMethod = EAdptSearchStroke;

            }

        }