/*

* Copyright (c) 2005-2008 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 );

//	iStates[++i] = EPeninputFingerHwrArStatePredictSelecting;

//    iStateHandlers[i] = 

//        CPeninputFingerHwrArStatePredictSelecting::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;

        case EHwrEventCandidateSelected:

            {

            OnSelectedCandidatesL(aEventData);

            }    

            break;

        case EHwrEventPredictiveSelected:

            {

//            OnSelectedPredictivesL(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 )

        {

        HBufC* defaultCandiate = candidates[0];

        if( iDataStore.IsSpecialDisplayChars( *defaultCandiate ) )

            {

            HBufC* realCandidate = iDataStore.ConvertDisplayChars( *defaultCandiate );

            iStateManager.HwrLayout().SubmitStringToFep( *realCandidate );

            delete realCandidate;

            }

        else

            {

            iStateManager.HwrLayout().SubmitStringToFep( *defaultCandiate );

            }

        //check if the default candidate is need to be sent directly

        if( iDataStore.IsDirectlySentCandidate( *defaultCandiate ) )

            {

            iStateManager.SetState( CPeninputFingerHwrArStateManager::

                EPeninputFingerHwrArStateStandby );

            }

        else

            {

            iStateManager.SetState( CPeninputFingerHwrArStateManager::

                EPeninputFingerHwrArStateCandidateSelecting );  

            }        

        } 

	}

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

// CPeninputFingerHwrArStateWriting::OnSelectedCandidatesL()

// .

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

//	

void CPeninputFingerHwrArStateWriting::OnSelectedCandidatesL( 

    const TDesC& aEventData )

    {

    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 ) ) );

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

    //handle special display char

    if( iDataStore.IsSpecialDisplayChars( ptr ) )

        {

        HBufC* realCandidate = iDataStore.ConvertDisplayChars( ptr );

        iStateManager.HwrLayout().SubmitStringToFep( ptr );

        delete realCandidate;

        }

    else

        {

        iStateManager.HwrLayout().SubmitStringToFep( ptr );         

        }        

    iDataStore.SetArabicSymbolL();

    // record the default cell highlight flag

    iDataStore.SetHighlight(EFalse);

//    iStateManager.SetState( 

//        CPeninputFingerHwrArStateManager::

//        EPeninputFingerHwrArStateStandby );     

    }

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

// CPeninputFingerHwrArStateWriting::OnEntry()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnEntry()

    {

    }

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

// CPeninputFingerHwrArStateWriting::OnExit()

// .

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

//

void CPeninputFingerHwrArStateWriting::OnExit()

    {

    }

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

//                     CPeninputFingerHwrStateHandlerCandidateSelecting class

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

// CPeninputFingerHwrArStateCandidateSelecting::

//                              CPeninputFingerHwrArStateCandidateSelecting()

// .

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

// 

CPeninputFingerHwrArStateCandidateSelecting::

    CPeninputFingerHwrArStateCandidateSelecting( 

	CPeninputFingerHwrArStateManager& aStateManager )

	:CPeninputFingerHwrArStateHandlerBase( aStateManager )

    {