/*

* Copyright (c) 2002-2005 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:  Implementation of HWR engine

*

*/

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <PtiHwrRecognizer.h>

#include "peninputhwrengine.h"

#include "peninputhwrbxdatastore.h"

// constant definition

const TInt KInvalidStrokeEndMarkX = -65536;

const TInt KInvalidStrokeEndMarkY = -65536;

//const TInt KMaxPredictiveCount = 50;

const TInt K1PagePredictiveCount = 36;

const TUint16 KGestureSpace = 0xF800;

const TUint16 KGestureEnter = 0xF801;

const TUint16 KSegment = 0x0020;

const TUint16 KGestureBackspace = 0x2408;

const TUint16 KDisplayBackspace = 0x2190;

const TInt KPremaryCandidateCount = 13;

const TInt KAuxCandidateCount = 1;

_LIT(KNumberSet,"0123456789");

_LIT(KSeparator,"\0");

_LIT(KDash,"-");

_LIT(KSolidus,"/");

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

// Symbian constructor

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

//

CAknFepHwrEngine* CAknFepHwrEngine::NewL(CPtiEngine* aPtiEngine, CAknFepHwrBxDataStore* aOwner)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aPtiEngine, aOwner);

    CleanupStack::Pop(self);//self

    return self;

    }

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

// C++ constructor

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

//

CAknFepHwrEngine::CAknFepHwrEngine():iRecognizerInited(EFalse),

                                     iNeedSetNumberMode(EFalse),

                                     iNeedSetCase(EFalse),

                                     iNeedSetRange(EFalse)

    {

    }

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

// destructor

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

//

CAknFepHwrEngine::~CAknFepHwrEngine()

    {

    if(iOwnPtiEngine)

        {

        delete iPtiEngine;

        }

    delete iCustomKeymap;

    delete iIdle;

    iPermittedRanges.Reset();

    iPermittedRanges.Close();

    }

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

// Second phase constructor

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

//

void CAknFepHwrEngine::ConstructL(CPtiEngine* aPtiEngine, CAknFepHwrBxDataStore* aOwner)

    {

    iPtiEngine = aPtiEngine;

    if( !iPtiEngine )

        {

        iPtiEngine = CPtiEngine::NewL(ETrue);

        iOwnPtiEngine = ETrue;

        }

    iIdle = CIdle::NewL(CActive::EPriorityIdle);

    iOwner = aOwner;

    }

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

// Convert stroke end mark

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

//

void CAknFepHwrEngine::ConvertStrokeEndMark(RArray<TPoint>& aTraceData, TPoint aPnt1, TPoint aPnt2)

    {

    TInt count = aTraceData.Count();

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

        {

    	if (aTraceData[i] == aPnt1)

    	    {

    		aTraceData.Remove(i);

    		aTraceData.Insert(aPnt2, i);

    	    }

        }

    }

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

// Do recoginize by engine

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

//

void CAknFepHwrEngine::DoRecognizeL(const RArray<TPoint>& aTraceData,

                                    RPointerArray<HBufC>& aCandidates)

    {

    if (!iRecognizer)

        {

        return;

        }

    TPoint ctrlStrokeEndMark = iOwner->StrokeEndMarkFromControl();

    if (!iRecognizerInited)

        {

        DoIdleConstructL();

        }

    if (ctrlStrokeEndMark != iRecognizer->StrokeEndMark())

        {

        ConvertStrokeEndMark(CONST_CAST(RArray<TPoint>&, aTraceData), 

                             iOwner->StrokeEndMarkFromControl(), 

                             iRecognizer->StrokeEndMark());

        iOwner->SetStrokeEndMark(); // make control's stroke end mark info same to engine

        }

    aCandidates.ResetAndDestroy();

    TInt primaryCount;  

    TBuf<1> bufBackspace;

    bufBackspace.Append(KGestureBackspace);

    TBuf<1> bufDisplayBackspace;

    bufDisplayBackspace.Append(KDisplayBackspace);

    if (iOwner->IsNumberOnly())

        {     

        if ( iNumberMode == EAknEditorPlainNumberModeKeymap )

            {

            TBuf<1> bufEnter;

            bufEnter.Append( KGestureEnter );

            TBuf<1> bufSpace;

            bufSpace.Append( KGestureSpace );

            TBuf<13> buf;

            buf.Append( KNumberSet() );

            buf.Append( bufBackspace );

            buf.Append( bufEnter );

            buf.Append( bufSpace );

            primaryCount = iRecognizer->RecognizeWithCharSet(

                aTraceData, aCandidates, buf );

            }

        else

            {

            primaryCount = iRecognizer->Recognize(aTraceData, aCandidates);

            }

        for ( TInt i = aCandidates.Count() - 1; i >= 0; i-- )

            {

            if (aCandidates[i]->Compare(bufBackspace) == 0)

            	{

                *aCandidates[i] = bufDisplayBackspace;

            	}

            }

        if (iCustomKeymap)

            {

            for(TInt i=0; i<aCandidates.Count(); i++)

                {

                if( iCustomKeymap->Find(*aCandidates[i]) == KErrNotFound )

                    {

                    delete aCandidates[i];

    		    	aCandidates.Remove(i);

    		    	primaryCount--;

    		    	i--;

                    }

                }

            }

        for (TInt i = 0; i < primaryCount-iTotalCandidateNum; i++)

            {

            delete aCandidates[iTotalCandidateNum];

            aCandidates.Remove(iTotalCandidateNum);

            }

        return;

        }

    primaryCount = iRecognizer->Recognize(aTraceData, aCandidates); 

    // remove uncessary primary candidate

    TInt removePos = iTotalCandidateNum - (iRangeCount - 1);        

    if (removePos >= 0)

        {

        for (TInt i = 0; i < primaryCount - removePos; i++)

            {

            delete aCandidates[removePos];

            aCandidates.Remove(removePos);

            }

        }     

    // filter recognized candidate, set start position for all ranges    

    TPtrC ptr(KSeparator);

    // remove uncessary aux candidate, including range separator 

    for (TInt i=0; i<aCandidates.Count(); i++)

        {

        if (aCandidates[i]->Compare(bufBackspace) == 0)

        	{

        	// convert backspace returned by engine, to make sure it display correctly.

            *aCandidates[i] = bufDisplayBackspace;

        	}

        else if ( (aCandidates[i]->CompareC(ptr) == 0) )

            {

            // remove separator from candidate list

            delete aCandidates[i];

            aCandidates.Remove(i);

            }

        }

    TPtrC dashPtr(KDash);

    TPtrC solidusPtr(KSolidus);

    // not allowing '-' to be the first char in chinese range 

    // not allowing '/' to be the first char in English and Number range 

    if ( ( iPremaryRange == ERangeNative ) && (aCandidates[0]->Compare(dashPtr) == 0) )

        {

        *aCandidates[0] = *aCandidates[1];

        *aCandidates[1] = dashPtr;

        }

    else if ( ( (iPremaryRange == ERangeEnglish)||(iPremaryRange == ERangeNumber) ) 

        && (aCandidates[0]->Compare(solidusPtr) == 0) )

        {

        *aCandidates[0] = *aCandidates[1];

        *aCandidates[1] = solidusPtr;

        }

    }

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

// Judge if candidate exist in given position

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

//

TBool CAknFepHwrEngine::CandidateExisted()

    {

	return iPtiEngine->MoreCandidatePages();

    }

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

// Do predictive using trigger string

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

//

void CAknFepHwrEngine::DoPredictiveL(const TDesC& aTriggerStr, 

                                     RPointerArray<HBufC>& aPredictives,

                                     TBool aNextPage)

    {

    // predictive only valid for Chinese

    if (((iLanguage == ELangPrcChinese) || 

        (iLanguage == ELangTaiwanChinese) || 

        (iLanguage == ELangHongKongChinese)) &&

        (iPtiEngine))

        {

        // activate correct pti language according to given language

        if (!aNextPage)

            {

        	iPtiEngine->SetCandidatePageLength(K1PagePredictiveCount);

        	aPredictives.ResetAndDestroy();

        	if(!iPtiEngine->SetPredictiveChineseChar(aTriggerStr))

        	    {

        	    return;

        	    }

            }

        else

            {

            if (!iPtiEngine->NextCandidatePage())

                {

            	return;

                }

            }

        TPtrC ptr = iPtiEngine->CandidatePage();    

        if ((iPtiEngine->InputMode() == EPtiEnginePinyinByPhrase) || 

            (iPtiEngine->InputMode() == EPtiEngineStrokeByPhrase) ||

            (iPtiEngine->InputMode() == EPtiEngineZhuyinByPhrase))

        	{

        	// phrase input mode

            TInt start = 0;

            TInt length = 0;

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

                {

                if (ptr[i] == KSegment)

                    {

                    TPtrC segment(ptr.Ptr() + start, length);

                    TRAP_IGNORE(aPredictives.AppendL(segment.AllocL()));

                    start += (length + 1);

                    length = 0;

                    }

                else

                    {

                    length++;               

                    }

                }

            if (length)

                {

                TPtrC segm(ptr.Ptr() + start, length);

                TRAP_IGNORE(aPredictives.AppendL(segm.AllocL()));

                }

        	}

        else

            {

            TInt predictiveCandidateNum = ptr.Length();

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

                {

                aPredictives.Append(ptr.Mid(i,1).AllocL());

                }

            }	

        }

    }

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

// Set primary and auxiliary ranges for hwr engine

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

//

void CAknFepHwrEngine::SetRanges(const RArray<TInt>& aPermittedRanges)

    {

    if (!iRecognizerInited)

        {

    	iNeedSetRange = ETrue;

    	iPermittedRanges.Reset();

    	for (TInt i = 0; i < aPermittedRanges.Count(); i++)

    	    {

            iPermittedRanges.Append(aPermittedRanges[i]);

    	    }

    	return;    

        }

    if ((aPermittedRanges.Count() > 0) && (iRecognizer))

        {

        iPremaryRange = aPermittedRanges[0];

        iRangeCount = aPermittedRanges.Count();

        TRecognitionRange range;

        SetRecognitionRange(aPermittedRanges[0], range);

        iRecognizer->SetRange(range);

        // set auxiliary ranges for hwr engine

        for (TInt i=1; i<aPermittedRanges.Count(); i++)

            {

            SetRecognitionRange(aPermittedRanges[i], range);

            iRecognizer->AddAuxiliaryRange(range);

            }

        SetCase(iCase);

        }

    }

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

// Set case

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

//

void CAknFepHwrEngine::SetCase(TInt aCase)

    {

    if (!iRecognizerInited)

        {

    	iNeedSetCase = ETrue;

    	iCase = aCase;

    	return;

        }

    // set letter to lower first when LowerCase

    // set letter to upper first when UpperCase and TextCase

    if (iRecognizer)

        {

        if (aCase == ELowerCase)

            {

            iRecognizer->SetFirstLetterOrder(ELowerFirst);

            }

        else

            {

            iRecognizer->SetFirstLetterOrder(EUpperFirst);

            }

        iCase = aCase;

        }

    }

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

// Set number mode for hwr engine

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

//

void CAknFepHwrEngine::SetNumberMode(const TAknEditorNumericKeymap& aNumberMode)

    {

    iNumberMode = aNumberMode;

    if (!iRecognizerInited)

        {

        iNeedSetNumberMode = ETrue;

    	return;

        }

    if (iRecognizer)

        {

        iRecognizer->SetNumberMode(aNumberMode);

        if( aNumberMode !=  EKeymapFromResource)

            {

            ResetCustomKeyMap();

            }

        }

    }

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

// Get stroke end mark from hwr engine

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

//

TPoint CAknFepHwrEngine::StrokeEndMark() const

    {

    if (iRecognizer)

        {

        return iRecognizer->StrokeEndMark();

        }

    else

        {

        return TPoint(KInvalidStrokeEndMarkX, KInvalidStrokeEndMarkY);

        }

    }

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

// Set primary candidate num for hwr engine

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

//

TInt CAknFepHwrEngine::SetPrimaryCandidateNum(TInt aNum)

    {

    if (iRecognizer)

        {

        return iRecognizer->SetCandidateNum(aNum);

        }

    else

        {

        return KErrGeneral;

        }

    }

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

// Set aux candidate num that should be shown

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

//

TInt CAknFepHwrEngine::SetAuxCandidateNum(TInt aNum)

    {

    if (iRecognizer)

        {

        return iRecognizer->SetAuxCandidateNum(aNum);

        }

    else

        {

        return KErrGeneral;

        }

    }

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

// Get aux candidate num that should be shown

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

//

TInt CAknFepHwrEngine::GetAuxCandidateNum()

    {

    if (iRecognizer)

        {

        return iRecognizer->GetAuxCandidateNum();

        }

    else

        {

        return KErrGeneral;

        }

    }

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

// Set total candidate num that should be shown

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

//

TInt CAknFepHwrEngine::SetCandidateNum(TInt aNum)

    {

    if (aNum > 0)

        {

        iTotalCandidateNum = aNum;

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }    

    }

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

// Set language