/*

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

*

*/

#include <peninputcmd.h>

#include "peninputfingerhwrarlayout.h"

#include "peninputfingerhwrarwnd.h"

#include "peninputfingerhwrarstatemanager.h"

#include "peninputfingerhwrardatastore.h"

#include "peninputfingerhwrarevent.h"

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

//                     CPeninputFingerHwrArStateHandlerBase class

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

// CPeninputFingerHwrArStateHandlerBase::CPeninputFingerHwrArStateHandlerBase()

// .

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

//

CPeninputFingerHwrArStateHandlerBase::CPeninputFingerHwrArStateHandlerBase( 

CPeninputFingerHwrArStateManagerBase& aStateManager )

    :iStateManager( aStateManager ),

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

    {

    }

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

// CPeninputFingerHwrArStateHandlerBase::~CPeninputFingerHwrArStateHandlerBase()

// .

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

//

CPeninputFingerHwrArStateHandlerBase::~CPeninputFingerHwrArStateHandlerBase()

    {

    }

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

//                     CPeninputFingerHwrStateManager class

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

// CPeninputFingerHwrStateManager::CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrArStateManagerBase::CPeninputFingerHwrArStateManagerBase( 

    CPeninputFingerHwrArLayout* aLayout )

    :iLayout(aLayout)

    {

    }

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

// CPeninputFingerHwrStateManager::~CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrArStateManagerBase::~CPeninputFingerHwrArStateManagerBase()

    {

    }

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

// CPeninputFingerHwrStateManager::CosntructL()

// .

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

//

void CPeninputFingerHwrArStateManagerBase::BaseConstructL()

    {

    }

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

// CPeninputFingerHwrArStateManagerBase::SetState()

// .

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

//    

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

    {

    }

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

// CPeninputFingerHwrArStateManagerBase::IsStandbyState()

// .

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

//

TBool CPeninputFingerHwrArStateManagerBase::IsStandbyState()

    {

    if(iCurrentState == 0)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CPeninputFingerHwrArStateManagerBase::HandleEventL()

// .

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

//    

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

    const TDesC& /*aEventData*/)

    {

    }

CPeninputFingerHwrArLayout& CPeninputFingerHwrArStateManagerBase::HwrLayout()

    {

    return *iLayout;

    }

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

//                     CPeninputFingerHwrStateManager class

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

// CPeninputFingerHwrArStateManager::NewL()

// .

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

//

CPeninputFingerHwrArStateManager* CPeninputFingerHwrArStateManager::NewL( 

    CPeninputFingerHwrArLayout* aLayout )

    {

    CPeninputFingerHwrArStateManager* self = new( ELeave ) 

        CPeninputFingerHwrArStateManager( aLayout );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPeninputFingerHwrArStateManager::CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrArStateManager::CPeninputFingerHwrArStateManager( 

    CPeninputFingerHwrArLayout* aLayout )

    :CPeninputFingerHwrArStateManagerBase( aLayout )

    {

    }

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

// CPeninputFingerHwrArStateManager::~CPeninputFingerHwrStateManager()

// .

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

//

CPeninputFingerHwrArStateManager::~CPeninputFingerHwrArStateManager()

    {

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

		{

		delete iStateHandlers[i];

		}

    }

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

// CPeninputFingerHwrArStateManager::CosntructL()

// .

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

//

void CPeninputFingerHwrArStateManager::ConstructL()

    {

    BaseConstructL();

    TInt i = 0;

    iStates[i] = EPeninputFingerHwrArStateStandby;

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

	iStates[++i] = EPeninputFingerHwrArStateWriting;

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

	iStates[++i] = EPeninputFingerHwrArStateCandidateSelecting;

    iStateHandlers[i] = 

        CPeninputFingerHwrArStateCandidateSelecting::NewL( *this );

    iCurrentStateHandler = iStateHandlers[0];

    iCurrentState = EPeninputFingerHwrArStateStandby;

    }

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

// CPeninputFingerHwrArStateManager::SetState()

// .

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

//    

void CPeninputFingerHwrArStateManager::SetState( TInt aState )

    {

    if( iCurrentState == aState )        

        {

        return;    

        }

    CPeninputFingerHwrArStateHandlerBase* newStateHandler = Find( (TPeninputFingerHwrArState)aState );

    if( newStateHandler )

        {

        iCurrentState = (TPeninputFingerHwrArState)aState;

        iCurrentStateHandler->OnExit();

        iCurrentStateHandler = newStateHandler;

        iCurrentStateHandler->OnEntry();

        }

    }

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

// CPeninputFingerHwrArStateManager::Find()

// .

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

//  

CPeninputFingerHwrArStateHandlerBase* CPeninputFingerHwrArStateManager::Find( 

    TPeninputFingerHwrArState aState )

    {

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

        {

        if( iStates[i] == aState )

            {

            return iStateHandlers[i];

            }

        }

    return NULL;

    }

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

// CPeninputFingerHwrArStateManager::HandleEventL()

// .

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

//    

void CPeninputFingerHwrArStateManager::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    iCurrentStateHandler->HandleEventL( aEventType, aEventData );

    }

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

//                     CPeninputFingerHwrStateHandlerStandby class

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

// CPeninputFingerHwrStateHandlerStandby::CPeninputFingerHwrStateHandlerStandby()

// .

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

// 

CPeninputFingerHwrArStateStandby::CPeninputFingerHwrArStateStandby( 

	CPeninputFingerHwrArStateManager& aStateManager )

	:CPeninputFingerHwrArStateHandlerBase( aStateManager )

    {

    }

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

// CPeninputFingerHwrStateHandlerStandby::NewL()

// .

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

// 

CPeninputFingerHwrArStateStandby* CPeninputFingerHwrArStateStandby::NewL( 

	CPeninputFingerHwrArStateManager& aStateManager )

    {

    CPeninputFingerHwrArStateStandby* self = new( ELeave ) 

        CPeninputFingerHwrArStateStandby( aStateManager );

    return self;

    }

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

// CPeninputFingerHwrStateHandlerStandby::HandleEventL()

// .

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

//

void CPeninputFingerHwrArStateStandby::HandleEventL( const TInt aEventType, 

    const TDesC& /*aEventData*/ )

    {

    switch( aEventType )

        {

        case EEventHwrStrokeStarted:

            {

            iStateManager.SetState( 

                CPeninputFingerHwrArStateManager::EPeninputFingerHwrArStateWriting );

            }

            break;

        default:

            break;

        }

    }

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

// CPeninputFingerHwrStateHandlerStandby::OnEntry()

// .

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

//

void CPeninputFingerHwrArStateStandby::OnEntry()

    {

//    iDataStore.TriggerStr()->DeleteAll();

    }

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

// CPeninputFingerHwrStateHandlerStandby::OnExit()

// .

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

//

void CPeninputFingerHwrArStateStandby::OnExit()

    {

    }

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

//                     CPeninputFingerHwrStateHandlerWriting class

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

// CPeninputFingerHwrArStateWriting::CPeninputFingerHwrStateHandlerWriting()

// .

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

// 

CPeninputFingerHwrArStateWriting::CPeninputFingerHwrArStateWriting( 

	CPeninputFingerHwrArStateManager& aStateManager )

	:CPeninputFingerHwrArStateHandlerBase( aStateManager )

    {

    }

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

// CPeninputFingerHwrArStateWriting::NewL()

// .

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

// 

CPeninputFingerHwrArStateWriting* CPeninputFingerHwrArStateWriting::NewL( 

	CPeninputFingerHwrArStateManager& aStateManager )

    {

    CPeninputFingerHwrArStateWriting* self = new( ELeave ) 

        CPeninputFingerHwrArStateWriting( aStateManager );

    return self;

    }

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

// CPeninputFingerHwrArStateWriting::HandleEventL()

// .

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

//

void CPeninputFingerHwrArStateWriting::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    switch( aEventType )

        {

        case EEventHwrStrokeFinished:

            {

            OnEndStrokeL(aEventData);

            }

            break;

        case EEventHwrCharacterTimerOut:

            {

            OnEndWritingL( aEventData );

            }

            break;

        default:

            break;

        }

    }

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

// CPeninputFingerHwrArStateWriting::OnEndStrokeL()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnEndStrokeL( const TDesC& aEventData )

	{

	const RArray<TPoint>* aTraceData = ( RArray<TPoint>* )aEventData.Ptr();

    iDataStore.DoRecognizeL( *aTraceData );

	}

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

// CPeninputFingerHwrArStateWriting::OnEndWriting()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnEndWritingL( const TDesC& /*aEventData*/ )

	{

    // record the default cell highlight flag.

    iDataStore.SetHighlight(ETrue);

    // This is a workarround to clear the recognizer.

    RArray<TPoint> stroke_array;

    stroke_array.Reset(); 

    // Call recognize with a empty array of stroke is the condition

    // to clear the context>

    iDataStore.DoRecognizeL(stroke_array );      

    RPointerArray<HBufC> candidates = iDataStore.Candidate();

    if ( candidates.Count() > 0 )

        {

		if(iStateManager.HwrLayout().IsAllowedToSubmitDefaultCandiate())

		    {

			iStateManager.HwrLayout().SubmitStringToFep( *candidates[0]);

			}

        iStateManager.SetState( CPeninputFingerHwrArStateManager::

                EPeninputFingerHwrArStateCandidateSelecting );  

        } 

	}

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

// CPeninputFingerHwrArStateWriting::OnEntry()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnEntry()

    {

    }

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

// CPeninputFingerHwrArStateWriting::OnExit()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnExit()

    {

    }

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

//                     CPeninputFingerHwrStateHandlerCandidateSelecting class

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

// CPeninputFingerHwrArStateCandidateSelecting::

//                              CPeninputFingerHwrArStateCandidateSelecting()

// .

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

// 

CPeninputFingerHwrArStateCandidateSelecting::

    CPeninputFingerHwrArStateCandidateSelecting( 

	CPeninputFingerHwrArStateManager& aStateManager )

	:CPeninputFingerHwrArStateHandlerBase( aStateManager )

    {

    }

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

// CPeninputFingerHwrArStateCandidateSelecting::NewL()

// .

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

// 

CPeninputFingerHwrArStateCandidateSelecting* 

    CPeninputFingerHwrArStateCandidateSelecting::NewL( 

	CPeninputFingerHwrArStateManager& aStateManager )

    {

    CPeninputFingerHwrArStateCandidateSelecting* self = new( ELeave ) 

        CPeninputFingerHwrArStateCandidateSelecting( aStateManager );

    return self;                                                                                

    }

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

// CPeninputFingerHwrArStateCandidateSelecting::HandleEventL()

// .

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

//

void CPeninputFingerHwrArStateCandidateSelecting::HandleEventL( const TInt aEventType, 

    const TDesC& aEventData )

    {

    switch( aEventType )

        {

        case EHwrEventCandidateSelected:

            {

            OnSelectedCandidatesL( aEventData );

            }

            break;

        case EHwrEventKeyBack:

            {

            OnClickBackSpaceL();

            }

            break;

        case EEventHwrStrokeStarted:

            {

            iStateManager.SetState( CPeninputFingerHwrArStateManager::

                EPeninputFingerHwrArStateWriting );

            }

            break;                     

        default:

            break;

        }

    }

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

// CPeninputFingerHwrStateHandlerCandidateSelecting::OnSelectedCandidatesL()

// .

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

//    

void CPeninputFingerHwrArStateCandidateSelecting::OnSelectedCandidatesL( 

    const TDesC& aEventData )

    {

    //get the candidate index

    const TInt cellNo = aEventData[aEventData.Length()-1];

    if (!iDataStore.IsValidCandidate( cellNo ))

        {

        iStateManager.SetState( CPeninputFingerHwrArStateManager::

                        EPeninputFingerHwrArStateStandby );

        return;

        }    

    TPtrC ptr;

    ptr.Set( ( aEventData.Left( aEventData.Length() - 1 ) ) );

	if(!iStateManager.HwrLayout().IsAllowedToSubmitDefaultCandiate())

		{

		iStateManager.HwrLayout().SubmitStringToFep( ptr);

		}

	else

        {

		RPointerArray<HBufC> candidates = iDataStore.Candidate();

		//the selected char is not same as default

		//replace the default candidate

		HBufC* defaultCandidate = candidates[0];