/*

* 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 for chinese peninput finger hwr

*

*/

#include <peninputcmd.h>

#include "peninputfingerhwrlayout.h"

#include "peninputfingerhwrwnd.h"

#include "peninputfingerhwrstatemanager.h"

#include "peninputfingerhwrdatastore.h"

#include "peninputfingerhwrevent.h"

#include "peninputfingerhwrtriggerstr.h"

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

//                     CPeninputFingerHwrStateHandlerBase class

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

// CPeninputFingerHwrStateHandlerBase::CPeninputFingerHwrStateHandlerBase()

// .

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

//

CPeninputFingerHwrStateHandlerBase::CPeninputFingerHwrStateHandlerBase( 

    CPeninputFingerHwrStateManagerBase& aStateManager )

    :iStateManager( aStateManager ),

    iDataStore( aStateManager.HwrLayout().DataStore() )

    {

    }

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

// CPeninputFingerHwrStateHandlerBase::~CPeninputFingerHwrStateHandlerBase()

// .

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

//

CPeninputFingerHwrStateHandlerBase::~CPeninputFingerHwrStateHandlerBase()

    {

    }

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

//                     CPeninputFingerHwrStateManager class

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

// CPeninputFingerHwrStateManager::CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerBase::CPeninputFingerHwrStateManagerBase( 

    CPeninputFingerHwrLayout* aLayout )

    :iLayout(aLayout)

    {

    }

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

// CPeninputFingerHwrStateManager::~CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerBase::~CPeninputFingerHwrStateManagerBase()

    {

    }

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

// CPeninputFingerHwrStateManager::CosntructL()

// .

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

//

void CPeninputFingerHwrStateManagerBase::BaseConstructL()

    {

    }

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

// CPeninputFingerHwrStateManagerBase::SetState()

// .

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

//    

void CPeninputFingerHwrStateManagerBase::SetState( TInt /*aState*/ )

    {

    }

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

// CPeninputFingerHwrStateManagerBase::IsStandbyState()

// .

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

//

TBool CPeninputFingerHwrStateManagerBase::IsStandbyState()

    {

    if(iCurrentState == 0)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CPeninputFingerHwrStateManagerBase::HandleEventL()

// .

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

//    

void CPeninputFingerHwrStateManagerBase::HandleEventL( const TInt /*aEventType*/,

    const TDesC& /*aEventData*/)

    {

    }

CPeninputFingerHwrLayout& CPeninputFingerHwrStateManagerBase::HwrLayout()

    {

    return *iLayout;

    }

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

//                     CPeninputFingerHwrStateManager class

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

// CPeninputFingerHwrStateManagerCn::NewL()

// .

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

//

CPeninputFingerHwrStateManagerCn* CPeninputFingerHwrStateManagerCn::NewL( 

    CPeninputFingerHwrLayout* aLayout )

    {

    CPeninputFingerHwrStateManagerCn* self = new( ELeave ) 

        CPeninputFingerHwrStateManagerCn( aLayout );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPeninputFingerHwrStateManagerCn::CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerCn::CPeninputFingerHwrStateManagerCn( 

    CPeninputFingerHwrLayout* aLayout )

    :CPeninputFingerHwrStateManagerBase( aLayout )

    {

    }

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

// CPeninputFingerHwrStateManagerCn::~CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerCn::~CPeninputFingerHwrStateManagerCn()

    {

	for( int i = 0; i < EPeninputFingerHwrStateCountCn; ++i )

		{

		delete iStateHandlers[i];

		}

    }

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

// CPeninputFingerHwrStateManagerCn::CosntructL()

// .

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

//

void CPeninputFingerHwrStateManagerCn::ConstructL()

    {

    BaseConstructL();

    TInt i = 0;

    iStates[i] = EPeninputFingerHwrStateStandbyCn;

    iStateHandlers[i] = CPeninputFingerHwrChineseStateStandby::NewL( *this );

	iStates[++i] = EPeninputFingerHwrStateWritingCn;

    iStateHandlers[i] = CPeninputFingerHwrChineseStateWriting::NewL( *this );

	iStates[++i] = EPeninputFingerHwrStateCandidateSelectingCn;

    iStateHandlers[i] = 

        CPeninputFingerHwrChineseStateCandidateSelecting::NewL( *this );

	iStates[++i] = EPeninputFingerHwrStatePredictSelectingCn;

    iStateHandlers[i] = 

        CPeninputFingerHwrChineseStatePredictSelecting::NewL( *this );              

    iCurrentStateHandler = iStateHandlers[0];

    iCurrentState = EPeninputFingerHwrStateStandbyCn;

    }

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

// CPeninputFingerHwrStateManagerCn::SetState()

// .

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

//    

void CPeninputFingerHwrStateManagerCn::SetState( TInt aState )

    {

    if( iCurrentState == aState )        

        {

        return;    

        }

    CPeninputFingerHwrStateHandlerBase* newStateHandler = Find( (TPeninputFingerHwrStateCn)aState );

    if( newStateHandler )

        {

        iCurrentState = (TPeninputFingerHwrStateCn)aState;

        iCurrentStateHandler->OnExit();

        iCurrentStateHandler = newStateHandler;

        iCurrentStateHandler->OnEntry();

        }

    }

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

// CPeninputFingerHwrStateManagerCn::Find()

// .

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

//  

CPeninputFingerHwrStateHandlerBase* CPeninputFingerHwrStateManagerCn::Find( 

    TPeninputFingerHwrStateCn aState )

    {

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

        {

        if( iStates[i] == aState )

            {

            return iStateHandlers[i];

            }

        }

    return NULL;

    }

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

// CPeninputFingerHwrStateManagerCn::HandleEventL()

// .

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

//    

void CPeninputFingerHwrStateManagerCn::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    iCurrentStateHandler->HandleEventL( aEventType, aEventData );

    }

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

//                     CPeninputFingerHwrStateManagerEn class

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

// CPeninputFingerHwrStateManagerEn::NewL()

// .

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

//

CPeninputFingerHwrStateManagerEn* CPeninputFingerHwrStateManagerEn::NewL( 

    CPeninputFingerHwrLayout* aLayout )

    {

    CPeninputFingerHwrStateManagerEn* self = new( ELeave ) 

        CPeninputFingerHwrStateManagerEn( aLayout );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPeninputFingerHwrStateManagerEn::CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerEn::CPeninputFingerHwrStateManagerEn( 

    CPeninputFingerHwrLayout* aLayout )

    :CPeninputFingerHwrStateManagerBase( aLayout )

    {

    }

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

// CPeninputFingerHwrStateManagerEn::~CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrStateManagerEn::~CPeninputFingerHwrStateManagerEn()

    {

	for( int i = 0; i < EPeninputFingerHwrStateCountEn; ++i )

		{

		delete iStateHandlers[i];

		}

    }

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

// CPeninputFingerHwrStateManagerEn::CosntructL()

// .

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

//

void CPeninputFingerHwrStateManagerEn::ConstructL()

    {

    BaseConstructL();

    TInt i = 0;

    iStates[i] = EPeninputFingerHwrStateStandbyEn;

    iStateHandlers[i] = CPeninputFingerHwrEnglishStateStandby::NewL( *this );

	iStates[++i] = EPeninputFingerHwrStateWritingEn;

    iStateHandlers[i] = CPeninputFingerHwrEnglishStateWriting::NewL( *this );

	iStates[++i] = EPeninputFingerHwrStateCandidateSelectingEn;

    iStateHandlers[i] = 

        CPeninputFingerHwrEnglishStateCandidateSelecting::NewL( *this );

#ifdef RD_INTELLIGENT_TEXT_INPUT	

	iStates[++i] = EPeninputFingerHwrStatePredictSelectingEn;

    iStateHandlers[i] = 

        CPeninputFingerHwrEnglishStatePredictSelecting::NewL( *this );

#endif // RD_INTELLIGENT_TEXT_INPUT

    iCurrentStateHandler = iStateHandlers[0];

    iCurrentState = EPeninputFingerHwrStateStandbyEn;

    }

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

// CPeninputFingerHwrStateManagerEn::SetState()

// .

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

//    

void CPeninputFingerHwrStateManagerEn::SetState( TInt aState )

    {

    if( iCurrentState == aState )        

        {

        return;    

        }

    CPeninputFingerHwrStateHandlerBase* newStateHandler = 

            Find((TPeninputFingerHwrStateEn)aState);

    if( newStateHandler )

        {

        iCurrentState = (TPeninputFingerHwrStateEn)aState;

        iCurrentStateHandler->OnExit();

        iCurrentStateHandler = newStateHandler;

        iCurrentStateHandler->OnEntry();

        }

    }

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

// CPeninputFingerHwrStateManagerEn::Find()

// .

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

//  

CPeninputFingerHwrStateHandlerBase* CPeninputFingerHwrStateManagerEn::Find( 

    TPeninputFingerHwrStateEn aState )

    {

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

        {

        if( iStates[i] == aState )

            {

            return iStateHandlers[i];

            }

        }

    return NULL;

    }

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

// CPeninputFingerHwrStateManagerEn::HandleEventL()

// .

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

//    

void CPeninputFingerHwrStateManagerEn::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    iCurrentStateHandler->HandleEventL( aEventType, aEventData );

    }

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

//                     CPeninputFingerHwrStateManagerNum class

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

// CPeninputFingerHwrStateManagerNum::NewL()

// .

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

//

CPeninputFingerHwrStateManagerNum* CPeninputFingerHwrStateManagerNum::NewL( 

    CPeninputFingerHwrLayout* aLayout )

    {

    CPeninputFingerHwrStateManagerNum* self = new( ELeave ) 

        CPeninputFingerHwrStateManagerNum( aLayout );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPeninputFingerHwrStateManagerNum::CPeninputFingerHwrStateManagerNum()

// .

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

//

CPeninputFingerHwrStateManagerNum::CPeninputFingerHwrStateManagerNum( 

    CPeninputFingerHwrLayout* aLayout )

    :CPeninputFingerHwrStateManagerBase( aLayout )

    {

    }

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

// CPeninputFingerHwrStateManagerNum::~CPeninputFingerHwrStateManagerNum()

// .

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

//

CPeninputFingerHwrStateManagerNum::~CPeninputFingerHwrStateManagerNum()

    {

	for( int i = 0; i < EPeninputFingerHwrStateCountNum; ++i )

		{

		delete iStateHandlers[i];

		}

    }

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

// CPeninputFingerHwrStateManagerNum::CosntructL()

// .

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

//

void CPeninputFingerHwrStateManagerNum::ConstructL()

    {

    BaseConstructL();

    TInt i = 0;

    iStates[i] = EPeninputFingerHwrStateStandbyNum;

    iStateHandlers[i] = CPeninputFingerHwrNumericStateStandby::NewL( *this );

    iCurrentStateHandler = iStateHandlers[0];

    iCurrentState = EPeninputFingerHwrStateStandbyNum;

    }

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

// CPeninputFingerHwrStateManagerNum::SetState()

// .

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

//    

void CPeninputFingerHwrStateManagerNum::SetState( TInt aState )

    {

    if( iCurrentState == aState )        

        {

        return;    

        }

    CPeninputFingerHwrStateHandlerBase* newStateHandler = 

            Find((TPeninputFingerHwrStateNum)aState );

    if( newStateHandler )

        {

        iCurrentState = (TPeninputFingerHwrStateNum)aState;

        iCurrentStateHandler->OnExit();

        iCurrentStateHandler = newStateHandler;

        iCurrentStateHandler->OnEntry();

        }

    }

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

// CPeninputFingerHwrStateManagerNum::Find()

// .

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

//  

CPeninputFingerHwrStateHandlerBase* CPeninputFingerHwrStateManagerNum::Find( 

    TPeninputFingerHwrStateNum aState )

    {

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

        {

        if( iStates[i] == aState )

            {

            return iStateHandlers[i];

            }

        }

    return NULL;

    }

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

// CPeninputFingerHwrStateManagerNum::HandleEventL()

// .

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

//    

void CPeninputFingerHwrStateManagerNum::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    iCurrentStateHandler->HandleEventL( aEventType, aEventData );

    }    

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

//                     CPeninputFingerHwrStateHandlerStandby class

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

// CPeninputFingerHwrStateHandlerStandby::CPeninputFingerHwrStateHandlerStandby()

// .

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

// 

CPeninputFingerHwrChineseStateStandby::CPeninputFingerHwrChineseStateStandby( 

	CPeninputFingerHwrStateManagerCn& aStateManager )

	:CPeninputFingerHwrStateHandlerBase( aStateManager )

    {

    }

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

// CPeninputFingerHwrStateHandlerStandby::NewL()

// .

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

// 

CPeninputFingerHwrChineseStateStandby* CPeninputFingerHwrChineseStateStandby::NewL( 

	CPeninputFingerHwrStateManagerCn& aStateManager )

    {

    CPeninputFingerHwrChineseStateStandby* self = new( ELeave ) 

        CPeninputFingerHwrChineseStateStandby( aStateManager );

    return self;

    }

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

// CPeninputFingerHwrStateHandlerStandby::HandleEventL()

// .

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