/*

* 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:  CAknFepHwrBxDataStore implementation

*

*/

#include <centralrepository.h>

#include <aknfeppeninputenums.h>

#include <AknFepGlobalEnums.h>

#include "peninputhwrbxdatastore.h"

#include <AknFepInternalCRKeys.h>

#include <settingsinternalcrkeys.h>

#include "peninputhwrtriggerstr.h"

#include "peninputhwrengine.h"

#include "peninputhwrboxgroup.h"

#include "peninputpluginutils.h"

const TInt KCandidateCount = 9;

const TInt KDefaultStrokeEndMarkX = -65536;

const TInt KDefaultStrokeEndMarkY = -65536;

_LIT(KCategory, "AKNFEPHWR");

_LIT( KCharSpace,  "\xF800" );

_LIT( KCharEnter, "\xF801" );

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

// Symbian constructor

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

//

CAknFepHwrBxDataStore* CAknFepHwrBxDataStore::NewL(CPtiEngine* aPtiEngine)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aPtiEngine);

    CleanupStack::Pop(self);//self

    return self;

    }

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

// C++ constructor

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

//

CAknFepHwrBxDataStore::CAknFepHwrBxDataStore():iSizeChanging(EFalse)

    {

    iLanguage = ELangNone;

    }

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

// destructor

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

//

CAknFepHwrBxDataStore::~CAknFepHwrBxDataStore()

    {

    iSubscriberList.Close();

    iCandidates.ResetAndDestroy();

    iCandidates.Close();

    iPredictives.ResetAndDestroy();

    iPredictives.Close();

    iRangeStartPos.Close();

    iPermittedRanges.Close();

    delete iFepRepositoryWatcher;    

    delete iGSRepositoryWatcher;

    delete iRepositoryFep;

    delete iRepositorySetting;

    delete iTriggerStr;

    delete iHwrEngine;

    }

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

// Second phase constructor

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

//

void CAknFepHwrBxDataStore::ConstructL(CPtiEngine* aPtiEngine)

    {

    iRepositoryFep = CRepository::NewL( KCRUidAknFep );

    iRepositorySetting = CRepository::NewL( KCRUidPersonalizationSettings );

    iFepRepositoryWatcher = CAknFepRepositoryWatcher::NewL(

        KCRUidPersonalizationSettings,

        TCallBack(HandleFepRepositoryCallBack, this),

        iRepositoryFep);

    iGSRepositoryWatcher = CAknFepRepositoryWatcher::NewL(

        KCRUidPersonalizationSettings,

        TCallBack(HandleGSRepositoryCallBack, this),

        iRepositorySetting);

    iTriggerStr = new (ELeave) CAknFepHwrTriggerStr();

    iHwrEngine = CAknFepHwrEngine::NewL(aPtiEngine, this);

    }

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

// Is candidate in Chinese range

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

//

TBool CAknFepHwrBxDataStore::IsChinese(TInt aCandidateIndex) const

    {

    TInt posIndex = ( iCandidates.Count()-1 ) - aCandidateIndex;

    TInt rangeCount = iPermittedRanges.Count();

    if ( rangeCount-1-posIndex > 0 )

        {

        return (iPermittedRanges[rangeCount-1-posIndex] == ERangeNative);    

        }

    else

        {

        return (iPermittedRanges[0] == ERangeNative);    

        }

    }

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

// Do recoginize by engine

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

//

void CAknFepHwrBxDataStore::DoRecognizeL(const RArray<TPoint>& aTraceData)

    {

    if (iHwrEngine)

        {

        iHwrEngine->DoRecognizeL(aTraceData, iCandidates);

        }

    SetCandidates();

    }

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

// Do predictive using trigger string

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

//

void CAknFepHwrBxDataStore::DoPredictiveL()

    {

    //because engine does not support trigger string

    //only the last char is used

    TPtrC string = TriggerStr()->GetString();

    if (iHwrEngine)

        {

        iHwrEngine->DoPredictiveL(string, iPredictives);

        }

    if (PredictiveCount() > 0)

        {

        SetPredictives();

        }

    }

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

// Get the predictive count

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

//

TInt CAknFepHwrBxDataStore::PredictiveCount() const

    {

    return iPredictives.Count();

    }

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

// Get the candidate count

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

//

TInt CAknFepHwrBxDataStore::CandidateCount() const

    {

    return iCandidates.Count();

    }

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

// Add property subscriber

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

//

void CAknFepHwrBxDataStore::AddSubscriber(MAknFepHwrPropertySubscriber* aSubscriber)

    {

    if (aSubscriber)

        {

        const TInt index = iSubscriberList.Find(aSubscriber);

        if (index == KErrNotFound)

            {

            iSubscriberList.Append(aSubscriber);

            }

        }

    }

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

// Get the trigger string

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

//

CAknFepHwrTriggerStr* CAknFepHwrBxDataStore::TriggerStr() const

    {

    return iTriggerStr;

    }

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

// Set permitted ranges

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

//

void CAknFepHwrBxDataStore::SetPermittedRanges(TInt aPermittedRanges)

    {

    iPermittedRanges.Reset();

    //order can not be changed

    if (aPermittedRanges & ERangeNative)

        {

        iPermittedRanges.Append(ERangeNative);

        }

    if (aPermittedRanges & ERangeEnglish)

        {

        iPermittedRanges.Append(ERangeEnglish);

        }

    if (aPermittedRanges & ERangeNumber)

        {

        iPermittedRanges.Append(ERangeNumber);

        }

    if (aPermittedRanges & ERangeSymbol)

        {

        iPermittedRanges.Append(ERangeSymbol);

        }

    iIntRange = aPermittedRanges;

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&iIntRange), sizeof(iIntRange));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyPermittedRange, ptr);        

    ptr.Set(reinterpret_cast<TText*>(&iPermittedRanges[0]), sizeof(iPermittedRanges[0]));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyRange, ptr);        

    // set primary and auxiliary ranges for hwr engine

    if (iHwrEngine)

        {

        iHwrEngine->SetRanges(iPermittedRanges);

        }

    }

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

// Get the permitted ranges count

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

//

TInt CAknFepHwrBxDataStore::PermittedRangesCount() const

    {

    return iPermittedRanges.Count();

    }

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

// Set permitted cases

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

//

void CAknFepHwrBxDataStore::SetPermittedCases(TInt aPermittedCases)

    {

    iPermittedCases = aPermittedCases;

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&iPermittedCases), sizeof(iPermittedCases));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyPermittedCases, ptr);        

    }

TInt CAknFepHwrBxDataStore::PermittedCases()

    {

    return iPermittedCases;

    }

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

// Set premary range

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

//

void CAknFepHwrBxDataStore::SetPremaryRange(TInt aPremaryRange)

    {

    const TInt oldIndex = iPermittedRanges.Find(aPremaryRange);

    if (oldIndex > 0)

        {

        iPermittedRanges.Sort();

        const TInt index = iPermittedRanges.Find(aPremaryRange);

        iPermittedRanges.Remove(index);

        iPermittedRanges.Insert(aPremaryRange, 0);

        TPtrC ptr;

        ptr.Set(reinterpret_cast<TText*>(&iPermittedRanges[0]), sizeof(iPermittedRanges[0]));

        NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyRange, ptr);        

        // set primary and auxiliary ranges for hwr engine

        if (iHwrEngine)

            {

            iHwrEngine->SetRanges(iPermittedRanges);

            }

        }

    }

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

// Set case

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

//

void CAknFepHwrBxDataStore::SetCase(TInt aCase)

    {              

    if ( iPermittedRanges.Count() != 0 && iPermittedRanges[0] != ERangeEnglish )

        {

        return;

        }

    iCase = aCase;

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&iCase), sizeof(iCase));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyCase, ptr);

    if (iHwrEngine)

        {

        iHwrEngine->SetCase(iCase);

        }

    }

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

// Judge if a language is Chinese

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

//

TBool CAknFepHwrBxDataStore::LanguageIsChinese(TInt aLanguage)

    {

	if ((aLanguage == ELangPrcChinese) ||

	    (aLanguage == ELangHongKongChinese) ||

	    (aLanguage == ELangTaiwanChinese))

	    {

		return ETrue;

	    }

	return EFalse;    

    }

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

// Set real engine language

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

//

void CAknFepHwrBxDataStore::SetEngineLanguage(TInt aLanguage)

    {

    if (iHwrEngine)

        {

        TRAP_IGNORE(iHwrEngine->SetLanguageL(aLanguage));

        //iHwrEngine->SetPrimaryCandidateNum(KPremaryCandidateCount);

        iHwrEngine->SetCandidateNum(KCandidateCount);

        /*

        TPtrC ptr;            

        TPoint strokeEndMark = iHwrEngine->StrokeEndMark();

        ptr.Set(reinterpret_cast<TText*>(&strokeEndMark), sizeof(strokeEndMark));

        NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyStrokeEndMark, ptr);

        */

        }

    }

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

// Set stroke end mark

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

//

void CAknFepHwrBxDataStore::SetStrokeEndMark()

    {

    if (iHwrEngine)

        {

        TPtrC ptr;

        TPoint strokeEndMark = iHwrEngine->StrokeEndMark();

        ptr.Set(reinterpret_cast<TText*>(&strokeEndMark), sizeof(strokeEndMark));

        NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyStrokeEndMark, ptr);

        }

    }

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

// Set stroke end mark control

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

//

void CAknFepHwrBxDataStore::SetStrokeEndMarkControl(MAknFepHwrPropertySubscriber* aStrokeControl)

    {

    iStrokeControl = aStrokeControl;

    }

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

// stroke end mark from control

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

//

TPoint CAknFepHwrBxDataStore::StrokeEndMarkFromControl()

    {

	if (iStrokeControl)

	    {

		return iStrokeControl->StrokeEndMark();

	    }

	return TPoint(KDefaultStrokeEndMarkX, KDefaultStrokeEndMarkY);

    }

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

// Set language

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

//

void CAknFepHwrBxDataStore::SetLanguageL(TInt aLanguage)

    {

    if( iLanguage == aLanguage )

        {

        return;

        }

    if (!LanguageIsChinese(aLanguage) && (aLanguage != ELangEnglish))

        {

        return;

        }

    if (aLanguage == ELangEnglish)

        {

        TLanguage displayLang = User::Language();

        // set real language to a Chinese

        if (!LanguageIsChinese(iLanguage))

            {

            // original language is not Chinese

            if (LanguageIsChinese(displayLang))

                {

            	iLanguage = displayLang;

                }

            else

                {

                iLanguage = ELangPrcChinese;	

                }

            SetEngineLanguage(iLanguage);

            }

        }

    else

        {

        // aLanguage is Chinese

        if (iLanguage != aLanguage)

            {

        	iLanguage = aLanguage;

            SetEngineLanguage(iLanguage);

            }

        }

    // make sure whole window is visible

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertySizeChanged, KNullDesC);

    }

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

// Get language

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

//

TInt CAknFepHwrBxDataStore::InputLanguage()

    {

    return iLanguage;

    }

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

// Set writting speed

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

//

void CAknFepHwrBxDataStore::SetWritingSpeed(TInt aWritingSpeed)

    {

    TTimeIntervalMicroSeconds32 speed;

    switch (aWritingSpeed)

        {

        case EPenInputWritingSpeedVeryFast: 

            speed = EPenInputWritingCharDelayVeryFast;

            break;

        case EPenInputWritingSpeedFast: 

            speed = EPenInputWritingCharDelayFast;

            break;

        case EPenInputWritingSpeedNormal: 

            speed = EPenInputWritingCharDelayNormal;

            break;

        case EPenInputWritingSpeedSlow: 

            speed = EPenInputWritingCharDelaySlow;

            break;

        case EPenInputWritingSpeedVerySlow: 

            speed = EPenInputWritingCharDelayVerySlow;

            break;

        default:

            speed = EPenInputWritingCharDelayNormal;

            break;

        }

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&speed), sizeof(speed));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyWriteSpeed, ptr);        

    }

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

// Set trail drawing pen size

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

//

void CAknFepHwrBxDataStore::SetBoxPenSize(const TSize& aSize)

    {

    iPenSize = aSize;

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&iPenSize), sizeof(iPenSize));

    NotifySubscriber(MAknFepHwrPropertySubscriber::EAknFepHwrPropertyPenSize, ptr);        

    }

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

// Set trail drawing pen color

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

//

void CAknFepHwrBxDataStore::SetBoxPenColor(const TRgb& aCol)

    {

    iPenColor = aCol;

    TPtrC ptr;

    ptr.Set(reinterpret_cast<TText*>(&iPenColor), sizeof(iPenColor));