/*
* Copyright (c) 2009 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 peninput handwriting recognition
*
*/


#include <AknFepGlobalEnums.h>  // ELowerCase
#include <aknfeppeninputenums.h>    // ERangeHiraganaKanji, ...
#include <PtiHwrRecognizer.h>
#include <PtiEngine.h>

#include "peninputhwrboxrecognizer.h"

// constant definition
const TInt KInvalidStrokeEndMarkX = -65536;
const TInt KInvalidStrokeEndMarkY = -65536;

// ---------------------------------------------------------
// Symbian constructor
// ---------------------------------------------------------
//
CPeninputHwrBoxRecognizer* CPeninputHwrBoxRecognizer::NewL(CPtiEngine* aPtiEngine)
    {
    CPeninputHwrBoxRecognizer* self = new (ELeave) CPeninputHwrBoxRecognizer();

    CleanupStack::PushL(self);
    self->ConstructL(aPtiEngine);
    CleanupStack::Pop(self);//self

    return self;
    }

// ---------------------------------------------------------
// destructor
// ---------------------------------------------------------
//
CPeninputHwrBoxRecognizer::~CPeninputHwrBoxRecognizer()
    {
    }

// ---------------------------------------------------------
// Do recoginize by engine
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::DoRecognize(const RArray<TPoint>& aTraceData, RPointerArray<HBufC>& aCandidates, RArray<TInt>& aRangeStartPos)
    {
    if (iRecognizer != NULL)
        {
        aCandidates.ResetAndDestroy();

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

        // filter recognized candidate, remove unnecessary gesture when only number is permitted

        // filter recognized candidate, set start position for all ranges
        aRangeStartPos.Reset();

        _LIT(KSeparator,"\0");
        TPtrC ptr(KSeparator);

        if (primaryCount > 0)
            {
            // the start position of primary range is 0
            aRangeStartPos.Append(0);

            // remove uncessary primary candidate
            TInt removePos = iTotalCandidateNum - (iRangeCount - 1);
            TInt removeCount = primaryCount - removePos;

            if (removePos >= 0)
                {
                for (TInt i = 0; i < removeCount; i++)
                    {
                    delete aCandidates[removePos];
                    aCandidates.Remove(removePos);
                    }
                }

            // remove range separator
            for (TInt i=0; i<aCandidates.Count(); i++)
                {
                if (aCandidates[i]->CompareC(ptr) == 0)
                    {
                    // remove separator from candidate list
                    delete aCandidates[i];
                    aCandidates.Remove(i);
                    // the start position of next range is i
                    aRangeStartPos.Append(i);
                    }
                }
            }
        }
    }


// ---------------------------------------------------------
// Set primary and auxiliary ranges for hwr engine
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::SetRanges(const RArray<TInt>& aPermittedRanges)
    {
    if ((aPermittedRanges.Count() > 0) && (iRecognizer != NULL))
        {
        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 CPeninputHwrBoxRecognizer::SetCase(TInt aCase)
    {
    // set letter to lower first when LowerCase
    // set letter to upper first when UpperCase and TextCase
    if (iRecognizer != NULL)
        {
        if (ECaseLower == aCase || ECaseInverseText == aCase)
            {
            iRecognizer->SetFirstLetterOrder(ELowerFirst);
            }
        else if (ECaseUpper == aCase || ECaseText == aCase)
            {
            iRecognizer->SetFirstLetterOrder(EUpperFirst);
            }

        iCase = aCase;
        }
    }

// ---------------------------------------------------------
// Set number mode for hwr engine
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::SetNumberMode(const TAknEditorNumericKeymap& aNumberMode)
    {
    if (iRecognizer != NULL)
        {
        iRecognizer->SetNumberMode(aNumberMode);
        }
    }

// ---------------------------------------------------------
// Get stroke end mark from hwr engine
// ---------------------------------------------------------
//
TPoint CPeninputHwrBoxRecognizer::StrokeEndMark() const
    {
    if (iRecognizer != NULL)
        {
        return iRecognizer->StrokeEndMark();
        }
    else
        {
        return TPoint(KInvalidStrokeEndMarkX, KInvalidStrokeEndMarkY);
        }
    }

// ---------------------------------------------------------
// Set primary candidate num for hwr engine
// ---------------------------------------------------------
//
TInt CPeninputHwrBoxRecognizer::SetPrimaryCandidateNum(TInt aNum)
    {
    if (iRecognizer != NULL)
        {
        return iRecognizer->SetCandidateNum(aNum);
        }
    else
        {
        return KErrGeneral;
        }
    }

// ---------------------------------------------------------
// Set total candidate num that should be shown
// ---------------------------------------------------------
//
TInt CPeninputHwrBoxRecognizer::SetCandidateNum(TInt aNum)
    {
    if (aNum > 0)
        {
        iTotalCandidateNum = aNum;
        return KErrNone;
        }
    else
        {
        return KErrGeneral;
        }
    }

// ---------------------------------------------------------
// Set language
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::SetLanguageL(TInt aLanguage)
    {

    iLanguage = aLanguage;

    // select suitable hwr recognizer according to language
    iRecognizer = iPtiEngine->GetHwrRecognizerL(TLanguage(iLanguage));
    }

// --------------------------------------------------------------------------
// CPeninputHwrBoxRecognizer::SetInputAreaSize
// (other items were commented in a header)
// --------------------------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::SetInputAreaSize( TSize aSize )
    {
    if ( iRecognizer )
        {
        iRecognizer->SetInputAreaSize( aSize );
        }
    }

// ---------------------------------------------------------
// C++ constructor
// ---------------------------------------------------------
//
CPeninputHwrBoxRecognizer::CPeninputHwrBoxRecognizer()
    {
    }

// ---------------------------------------------------------
// Second phase constructor
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::ConstructL(CPtiEngine* aPtiEngine)
    {
    if (!aPtiEngine)
        {
        User::Leave(KErrArgument);
        }
    iPtiEngine = aPtiEngine;
    }

// ---------------------------------------------------------
// Set recognition range for hwr engine
// ---------------------------------------------------------
//
void CPeninputHwrBoxRecognizer::SetRecognitionRange(const TInt aRange, TRecognitionRange& aRecognitionRange) const
    {
    aRecognitionRange.iLanguage = TLanguage(iLanguage);

    switch (aRange)
        {
        case ERangeNative:
        case ERangeHiraganaKanji:
            aRecognitionRange.iSubRange = EPtiRangeHiraganaKanji;
            break;
        case ERangeKatakana:
            aRecognitionRange.iSubRange = EPtiRangeKatakana;
            break;
        case ERangeFullWidthKatakana:
            aRecognitionRange.iSubRange = EPtiRangeFullWidthKatakana;
            break;
        case ERangeFullWidthEnglish:
            aRecognitionRange.iSubRange = EPtiRangeFullWidthEnglish;
            break;
        case ERangeFullWidthNumeric:
            aRecognitionRange.iSubRange = EPtiRangeFullWidthNumeric;
            break;
        case ERangeHiraganaOnly:
            aRecognitionRange.iSubRange = EPtiRangeHiraganaOnly;
            break;
        case ERangeEnglish:
            aRecognitionRange.iSubRange = EPtiRangeLatin;
            break;
        case ERangeNumber:
            aRecognitionRange.iSubRange = EPtiRangeNumber;
            break;
        case ERangeSymbol:
            if (iPremaryRange == ERangeEnglish)
                {
                aRecognitionRange.iLanguage = ELangEnglish;
                }
            else
                {
                aRecognitionRange.iLanguage = TLanguage(iLanguage);
                }
            aRecognitionRange.iSubRange = EPtiRangeSymbol;
            break;
        default:
            break;
        }
    }

//End Of File