/*

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

*

*/

//  INCLUDES

#include <aknfeppeninputenums.h>

#include <peninputdropdownlist.h>

#include "peninputhwrbxlayout.h"

#include "peninputhwrbxwnd.h"

#include "peninputhwrbxstate.h"

#include "peninputhwrevent.h"

#include "peninputhwrbxdatastore.h"

#include "peninputhwrtriggerstr.h"

//CAknFepHwrBxStateBase

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

// C++ constructor

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

//

CAknFepHwrBxStateBase::CAknFepHwrBxStateBase(CAknFepHwrBxLayout* aLayout)

    {

    iLayout = aLayout;

    iWnd = NULL;

    iDataStore = NULL;

    if (iLayout)

        {

        iWnd = iLayout->Window();    

        iDataStore = iLayout->DataStore();

        }

    ASSERT(iLayout != NULL);

    ASSERT(iWnd != NULL);

    ASSERT(iDataStore != NULL);

    }

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

// Destructor

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

//

CAknFepHwrBxStateBase::~CAknFepHwrBxStateBase()

    {

    }

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

// Handle layout command event

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

//

TInt CAknFepHwrBxStateBase::HandleCommandL(TInt /*aCmd*/, TUint8* /*aData*/)

    {

    return KErrNone;

    }

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

// Handle raw event key

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

//

TBool CAknFepHwrBxStateBase::HandleKeyEventL(const TRawEvent& /*aKeyEvent*/)

    {

    return EFalse;

    }

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

// Handle raw event key

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

//

TBool CAknFepHwrBxStateBase::HandleEventL(TInt /*aEventType*/, const TDesC& /*aEventData*/)

    {

    //not handled

    return EFalse;

    }

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

// Doing something before entry a state

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

//

void CAknFepHwrBxStateBase::OnEntry()

    {

    }

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

// Doing something before exit a state

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

//

void CAknFepHwrBxStateBase::OnExit()

    {

    }

//CAknFepHwrBxStateBase end

//CAknFepHwrBxStateCloseable

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

// C++ constructor

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

//

CAknFepHwrBxStateCloseable::CAknFepHwrBxStateCloseable(CAknFepHwrBxLayout* aLayout)

: CAknFepHwrBxStateBase(aLayout)                          

    {

    }

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

// Destructor

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

//

CAknFepHwrBxStateCloseable::~CAknFepHwrBxStateCloseable()

    {

    }

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

// Handle ECmdPenInputWindowClose

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

//

TInt CAknFepHwrBxStateCloseable::HandleCommandL(TInt aCmd, TUint8* /*aData*/)

    {

    if (ECmdPenInputWindowClose == aCmd)

        {

        //jump to init state

        CAknFepHwrBxStateInit* state = CAknFepHwrBxStateInit::NewLC(iLayout);

        iLayout->SetCurrentStateL(state);

        CleanupStack::Pop(state);

        //record the close mode: automatically

        state->SetAutoClosed(ETrue);

        }

    return KErrNone;

    }

//CAknFepHwrBxStateCloseable end

//CAknFepHwrBxStateInit    

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

// Symbian constructor

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

//

CAknFepHwrBxStateInit* CAknFepHwrBxStateInit::NewLC(CAknFepHwrBxLayout* aLayout)

    {

    CAknFepHwrBxStateInit* self = new (ELeave) CAknFepHwrBxStateInit(aLayout);

    CleanupStack::PushL(self);

    return self;

    }

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

// C++ default constructor

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

//

CAknFepHwrBxStateInit::CAknFepHwrBxStateInit(CAknFepHwrBxLayout* aLayout)

: CAknFepHwrBxStateBase(aLayout)

    {

    iAutoClosed = ETrue;    

    }

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

// destructor

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

//

CAknFepHwrBxStateInit::~CAknFepHwrBxStateInit()

    {

    }

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

// Record last closed mode

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

//

void CAknFepHwrBxStateInit::SetAutoClosed(TBool aAutoFlag)

    {

    iAutoClosed = aAutoFlag;

    }

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

// Handle command

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

//

TInt CAknFepHwrBxStateInit::HandleCommandL(TInt aCmd, TUint8* aData)

    {

    return KErrNone;

    }

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

// Doing something before entry a state

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

//

void CAknFepHwrBxStateInit::OnEntry()

    {

    iWnd->CancelWriting();

    iWnd->CancelRepeat();

    iWnd->Hide(ETrue);

    }

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

// Doing something before exit a state

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

//

void CAknFepHwrBxStateInit::OnExit()

    {

    iWnd->Hide(EFalse);

    }

//CAknFepHwrBxStateInit end

//CAknFepHwrBxStateStandby

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

// Symbian constructor

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

//

CAknFepHwrBxStateStandby* CAknFepHwrBxStateStandby::NewLC(CAknFepHwrBxLayout* aLayout)

    {

    CAknFepHwrBxStateStandby* self = new (ELeave) CAknFepHwrBxStateStandby(aLayout);

    CleanupStack::PushL(self);

    return self;

    }

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

// Symbian constructor

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

//

CAknFepHwrBxStateStandby* CAknFepHwrBxStateStandby::NewL(CAknFepHwrBxLayout* aLayout)

    {

    CAknFepHwrBxStateStandby* self = CAknFepHwrBxStateStandby::NewLC( aLayout );

    CleanupStack::Pop(self);

    return self;

    }

// C++ default constructor

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

//

CAknFepHwrBxStateStandby::CAknFepHwrBxStateStandby(CAknFepHwrBxLayout* aLayout)

: CAknFepHwrBxStateCloseable(aLayout)

    {

    }

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

// destructor

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

//

CAknFepHwrBxStateStandby::~CAknFepHwrBxStateStandby()

    {

    }

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

// Handle event

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

//

TBool CAknFepHwrBxStateStandby::HandleEventL(TInt aEventType, const TDesC& /*aEventData*/)

    {

    TBool handled = ETrue;

    CAknFepHwrBxStateBase* state = NULL;

    switch (aEventType)

        {

        case EHwrEventBeginWriting:

            state = CAknFepHwrBxStateBeginWriting::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);//state

            break;

        case EHwrEventWindowClose:

            //jump to init state

            state = CAknFepHwrBxStateInit::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);

            //record the close mode: manully

            static_cast<CAknFepHwrBxStateInit*>(state)->SetAutoClosed(EFalse);

            handled = EFalse;

            break;        

        default:

            handled = EFalse;

            break;

        }

    return handled;

    }

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

// Doing something before entry a state

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

//

void CAknFepHwrBxStateStandby::OnEntry()

    {

    iDataStore->ClearCandidates();

    //cancel writing timer

    iWnd->CancelWriting();

    }

//CAknFepHwrBxStateStandby end

//CAknFepHwrBxStateBeginWriting

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

// Symbian constructor

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

//

CAknFepHwrBxStateBeginWriting* CAknFepHwrBxStateBeginWriting::NewLC(CAknFepHwrBxLayout* aLayout)

    {

    CAknFepHwrBxStateBeginWriting* self = new (ELeave) CAknFepHwrBxStateBeginWriting(aLayout);

    CleanupStack::PushL(self);

    return self;

    }

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

// C++ default constructor

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

//

CAknFepHwrBxStateBeginWriting::CAknFepHwrBxStateBeginWriting(CAknFepHwrBxLayout* aLayout)

: CAknFepHwrBxStateCloseable(aLayout)

    {

    }

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

// Destructor

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

//

CAknFepHwrBxStateBeginWriting::~CAknFepHwrBxStateBeginWriting()

    {

    }

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

// Handle event

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

//

TBool CAknFepHwrBxStateBeginWriting::HandleEventL(TInt aEventType, const TDesC& aEventData)

    {

    CAknFepHwrBxStateBase* state = NULL;

    switch (aEventType)

        {

        case EHwrEventEndStroke:

            {

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

            iDataStore->DoRecognizeL(*aTraceData);

            state = CAknFepHwrBxStateEndWriting::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);//state

            break;

            }

        default:

            break;

        }

    //All events are discarded.

    return ETrue;

    }

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

// Doing something before entry a state

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

//

void CAknFepHwrBxStateBeginWriting::OnEntry()

    {

    //disable draging

    //iWnd->SetDragEnable(EFalse);

    iWnd->DimInputContextField(ETrue);

    }

//CAknFepHwrBxStateBeginWriting end

//CAknFepHwrBxStateEndWriting

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

// Symbian constructor

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

//

CAknFepHwrBxStateEndWriting* CAknFepHwrBxStateEndWriting::NewLC(CAknFepHwrBxLayout* aLayout)

    {

    CAknFepHwrBxStateEndWriting* self = new (ELeave) CAknFepHwrBxStateEndWriting(aLayout);

    CleanupStack::PushL(self);

    return self;

    }

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

// C++ default constructor

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

//

CAknFepHwrBxStateEndWriting::CAknFepHwrBxStateEndWriting(CAknFepHwrBxLayout* aLayout)

: CAknFepHwrBxStateCloseable(aLayout)

    {

    }

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

// Destructor

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

//

CAknFepHwrBxStateEndWriting::~CAknFepHwrBxStateEndWriting()

    {

    }

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

// Handle event

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

//

TBool CAknFepHwrBxStateEndWriting::HandleEventL(TInt aEventType, const TDesC& aEventData)

    {

    TBuf<KMaxCandidateLen> charCode;

    TBool handled = ETrue;

    CAknFepHwrBxStateBase* state = NULL;

    switch (aEventType)

        {

        case EHwrEventNewWriting:

            //submit the first char to fep

            iDataStore->GetCandidate(0, charCode);

            iLayout->SubmitL(charCode);

            iDataStore->ClearCandidates();

            // fall-through intended here

        case EHwrEventBeginWriting:

            state = CAknFepHwrBxStateBeginWriting::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);//state

            break;

        case EHwrEventCandidateSelected:

            OnCandidateSelectedL(aEventData);

            break;

        case EHwrEventKeyBack:

            // fall-through intended here

        case EHwrEventPointerOutsideWnd:

            state = CAknFepHwrBxStateStandby::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);//state

            break;

        case EHwrEventEndWriting:

            {

            iDataStore->GetCandidate(0, charCode);

            iLayout->SubmitL(charCode);

            TPtrC16 ptrBack;

            TPtrC16 ptrEnter;

            ptrBack.Set(&KBackRep, sizeof(KBackRep)/2);

            ptrEnter.Set(&KEnterRep, sizeof(KEnterRep)/2);

            //if char code is backspace or enter

            if (charCode.CompareC(ptrBack) == 0 || charCode.CompareC(ptrEnter) == 0)

                {

                state = CAknFepHwrBxStateStandby::NewLC(iLayout);

                iLayout->SetCurrentStateL(state);

                }

            else

                {

                state = CAknFepHwrBxStateCandidateSelecting::NewLC(iLayout);

                iLayout->SetCurrentStateL(state);

                }

            CleanupStack::Pop(state);//state

            break;

            }

        case EHwrEventWindowClose:

            iDataStore->GetCandidate(0, charCode);

            iLayout->SubmitL(charCode);

            //jump to init state

            state = CAknFepHwrBxStateInit::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);

            //record the close mode: manully

            static_cast<CAknFepHwrBxStateInit*>(state)->SetAutoClosed(EFalse);

            handled = EFalse;

            break;        

        default:

            iDataStore->GetCandidate(0, charCode);

            iLayout->SubmitL(charCode);

            state = CAknFepHwrBxStateStandby::NewLC(iLayout);

            iLayout->SetCurrentStateL(state);

            CleanupStack::Pop(state);//state

            handled = EFalse;

            break;

        }

    return handled;

    }

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

// Handle raw event key

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

//

TBool CAknFepHwrBxStateEndWriting::HandleKeyEventL(const TRawEvent& /*aKeyEvent*/)

    {

    //code is removed because of submit char to wrong editor when focus changed

    /*

    TBuf<KMaxCandidateLen> charCode;

    iDataStore->GetCandidate(0, charCode);

    iLayout->SubmitL(charCode);

    CAknFepHwrBxStateBase* state = CAknFepHwrBxStateStandby::NewLC(iLayout);

    iLayout->SetCurrentStateL(state);

    CleanupStack::Pop(state);//state

    */

    return EFalse;

    }

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

// Handle EHwrEventCandidateSelected

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

//

void CAknFepHwrBxStateEndWriting::OnCandidateSelectedL(const TDesC& aEventData)

    {

    CAknFepHwrBxStateBase* state = NULL;