/*

* 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>

// 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 <AvkonInternalCRKeys.h>

#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 TInt16 KMinUnicodeHz = 0x4e00;

const TInt16 KStrokeHorizontalValue = 0x4e00;

const TInt16 KStrokeVerticalValue = 0x4e28;

const TInt16 KStrokeDownToLeftValue = 0x4e3f;

const TInt16 KStrokeDownToRightValue = 0x4e36;

const TInt16 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);

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

    iRepositoryFindAdaptive = CRepository::NewL(KCRUidAvkon);

#endif

    iWatcher = CFindRepositoryWatcher::NewL(KCRUidAknFep, 

        TCallBack(HandleFindRepositoryCallBack, this), 

        iRepositoryFind);

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

    iWatcherAdaptive = CFindRepositoryWatcher::NewL(KCRUidAvkon,

        TCallBack(HandleFindRepositoryCallBack, this),

        iRepositoryFindAdaptive);                                        

#endif

    iAlgorithm = aAlgorithm;

    OpenL();

    }

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

// CFindUtilChineseECE utils class

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

//

CFindUtilChineseECE::CFindUtilChineseECE() :

iLanguage(ELangTest),

iSupportPRCChinese(EFalse),

iCurInputMode(KSysInputMode)

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

iSearchMethodPRC(EAdptSearchPinyin),

iSearchMethodTaiWan(EAdptSearchZhuyin),

iSearchMethodHongKong(EAdptSearchStroke),

iSearchMethodAdaptive(EFalse)

#endif

    	    {

    	    }

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

// Destructor

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

//

CFindUtilChineseECE::~CFindUtilChineseECE()

    {

    delete iPtiEngine;

    delete iWatcher;

    delete iPtiEnginePrc;

    delete iRepositoryFind;

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

    delete iWatcherAdaptive;

    delete iRepositoryFindAdaptive;

#endif

    }

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

// Open ptiengine and active it by input language

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

//

TBool CFindUtilChineseECE::OpenT9InterfaceL(TLanguage aLanguage)

    {

    if (!iPtiEngine)

        {

        iPtiEngine = CPtiEngine::NewL();

        iSupportPRCChinese = IsSupportLanguage(ELangPrcChinese);

        }

    if (aLanguage != iLanguage)

        {

        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)

    {

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

    }

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

// Find pane text is including stroke symbol

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

//

TInt CFindUtilChineseECE::IsStrokeSymbol(const TInt 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;

    }

TInt CFindUtilChineseECE::CategoryOfLang(TLanguage aLanguage)

    {

    TInt ret = 0;

    if (iLanguage == ELangPrcChinese || ( aLanguage == ELangEnglish && iSupportPRCChinese ))

        {

        ret = 1;

        }

    else if (aLanguage == ELangTaiwanChinese)

        {

        ret = 2;

        }

    else if (aLanguage == ELangHongKongChinese)

        {

        ret = 3;

        }

    return ret;

    }

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

// Do translate for Chinese word

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

//

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

    {

    TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;

    TBuf<KMaxWordInterpretationLen> numInterpretationBuf;

    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;

    }

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

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

// Do translate for Chinese word

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

//

TBool CFindUtilChineseECE::T9ChineseTranslationAdaptiveL(TInt16 aHZUnicode,  

    RPointerArray<HBufC>& aSpellList)

    {

    TBuf<KMaxWordInterpretationLen> wordInterpretationBuf;

    if ( iLanguage == ELangPrcChinese )

        {

        if(iSearchMethodPRC == EAdptSearchPinyin)

            {

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

                != KErrNone)

                {

                return EFalse;

                }	

            }

        else if(iSearchMethodPRC == EAdptSearchStroke)    

            {

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

                != KErrNone)

                {

                return EFalse;

                }	

            }

        else

            {

            return EFalse;	

            }    

        }

    else if ( iLanguage == ELangTaiwanChinese )

        {

        if(iSearchMethodTaiWan == EAdptSearchZhuyin)

            {

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

                != KErrNone)

                {

                return EFalse;

                }	

            }

        else if(iSearchMethodTaiWan == EAdptSearchStroke)    

            {

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

                != KErrNone)

                {

                return EFalse;

                }	

            }

        else

            {

            return EFalse;	

            }       

        }

    else if ( iLanguage == ELangHongKongChinese )

        {

        switch(iSearchMethodHongKong)

            {

            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;

            case EAdptSearchStroke:

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

                    != KErrNone)

                    {

                    return EFalse;

                    }

                break;

            default:

                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;

        }

    TInt len = wordInterpretationBuf.Length();

    TInt start = 0;

    if( iSearchMethodHongKong != 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());