/*

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

*

*/

#include <PtiEngine.h>

#include <peninputlayout.h>

#include <PtiCompositionDataIF.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <peninputcommonlayoutglobalenum.h>  // EPeninputLayoutEventEnter

#include <aknfeppeninputenums.h>    //command from fep or IME to plugin. for vkb/hwr

#include "peninputeventjp.h"

#include "peninputhiraganakanji.h"

#include "peninputcontextfieldjp.h"

#include "peninputjapanesecandidatewnd.h"

#include "peninputjapanesepredictivewnd.h"

// CONSTANTS

const TUint16 KLittleCharCode = 0x5c0f; // little

//default value for long press timer

const TInt KLongPressInterval = 600000;

//default value for repeat timer

const TInt KRepeatInterval = 100000;

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

// Constructor

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

EXPORT_C CPeninputHiraganaKanji* CPeninputHiraganaKanji::NewL(CPtiEngine* aPtiEngine

                                                             , CFepUiLayout* aUiLayout

                                                             , CFepInputContextFieldJp* aInputContextField

                                                             , CPeninputJapaneseCandidateWnd* aCandidateWnd

                                                             , CPeninputJapanesePredictiveWnd* aPredictiveWnd)

    {

    if (aPtiEngine == NULL

         || aUiLayout == NULL

         || aInputContextField == NULL

         || aCandidateWnd == NULL

         || aPredictiveWnd == NULL

         )

        {

        User::Leave(KErrArgument);

        }

    CPeninputHiraganaKanji* self = new (ELeave) CPeninputHiraganaKanji(aPtiEngine

                                                                               , aUiLayout

                                                                               , aInputContextField

                                                                               , aCandidateWnd

                                                                               , aPredictiveWnd);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

EXPORT_C CPeninputHiraganaKanji::~CPeninputHiraganaKanji()

    {

    delete iCandidateArray;

    delete iChar;

    CancelRepeat();

    delete iLongPressTimer;

    delete iRepeatTimer;

    }

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

// Handle events in

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

EXPORT_C void CPeninputHiraganaKanji::HandleControlEventJpL(TInt aEventType, const TDesC& aEventData)

    {

    if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus

          || EStatusCompleteAllfromUiLayout == iStatus) // wait for SetEditorTextL from Editor

        {

        return ;

        }

    switch (aEventType)

        {

        case EEventVirtualKeyUp:

            if (!aEventData.Length())

                {

                UpdateContextFieldL();

                }

            else

                {

                TUint16* unicode = (TUint16*) aEventData.Ptr();

                if (EStatusInitial == iStatus)

                    {

                    if (KLittleCharCode != *unicode)

                        {

                        iInputContextField->StartInlineL();

                        iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;

                        }

                    }

                else if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                    {

                    if (KLittleCharCode != *unicode)

                        {

                        iInputContextField->StartInlineL();

                        iStatus = EStatusPredictiveTransitoryInput;

                        }

                    }

                if (EStatusPredictiveTransitoryInput == iStatus || EStatusTransitoryInput == iStatus)

                    {

                    // different from editor

                    iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;

                    HandleInsertL(aEventData);

                    }

                else if (EStatusConversion == iStatus

                       || EStatusCandidate == iStatus  // not take place

                       || EStatusChangeDivision == iStatus)

                    {

                    delete iChar;

                    iChar = NULL;

                    iChar = aEventData.AllocL();

                    CompleteAllL();

                    }

                }

            break;

        case EEventCompleteAllHiraganaKanji:    // CompleteALL:from UiLayout

            if (EStatusInitial != iStatus)

                {

                if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                    {

                    iStatus = EStatusInitial;

                    UpdateContextFieldL();  // not leave

                    }

                else

                    {

                    iStatus = EStatusCompleteAllfromUiLayout;

                    CompleteAllL();

                    }

                }

            break;

        case EEventCompleteIfConvertingHiraganaKanji:    // Complete:from Hwr UiLayout

            if (EStatusConversion == iStatus

               || EStatusCandidate == iStatus  // not take place

               || EStatusChangeDivision == iStatus)

                {

                iStatus = EStatusCompleteAllfromUiLayout;

                CompleteAllL();

                }

            break;

        case EPeninputLayoutEventSelectItem:  // select from prediction/convert candidates by pointer

        case EPeninputLayoutEventEnter:

            if (EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                {

                TInt curr = iPredictiveWnd->CurrentItemIndexOfCandidate();

                if (curr >= 0)

                    {

                    iPtiEngine->HandleCommandL(EPtiCommandUserActionCompleteCandidate, &curr);

                    CompleteSubL();  // not leave

                    }

                break;

                }

            if (EStatusCandidate == iStatus)

                {

                TInt curr = iCandidateWnd->CurrentItemIndex();

                TInt old = 0;

                iPtiEngine->HandleCommandL(EPtiCommandUserActionGetCurrentIndexOfCandidates, &old);

                while(curr > old)

                    {

                    ++old;

                    iPtiEngine->HandleCommandL(EPtiCommandUserActionConvert);

                    }

                while(curr < old)

                    {

                    --old;

                    iPtiEngine->HandleCommandL(EPtiCommandUserActionPrevious);

                    }

                }

            if (EStatusInitial != iStatus)

                {

                CompleteL();

                }

            break;

        case EPeninputLayoutEventBack:

            {

            switch(iStatus)

                {

                case EStatusPredictiveTransitoryInputWithNoChar:

                    {

                    iStatus = EStatusInitial;

                    UpdateContextFieldL();  // not leave

                    }

                    break;

                case EStatusTransitoryInput:

                case EStatusPredictiveTransitoryInput:

                    {

                    // different from editor

                    iStatus = (!iPredictiveWnd->Hiden())? EStatusPredictiveTransitoryInput : EStatusTransitoryInput;

                    HandleBackL();

                    }

                    break;

                case EStatusCandidate:

                    {

                    iStatus = EStatusConversion;

                    UpdateContextFieldL();

                    }

                    break;

                case EStatusConversion:

                case EStatusChangeDivision:

                    {

                    iPtiEngine->HandleCommandL(EPtiCommandUserActionCancel);

                    iStatus = EStatusTransitoryInput;

                    UpdateContextFieldL();

                    }

                    break;

                default:

                    break;

                }

            }

            break;

        case EEventStdKeyUpArrow:

        case EEventStdKeyDownArrow:

        case EPeninputLayoutEventSpace:

            if (EStatusInitial != iStatus)

                {

                if ((EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                          && EPeninputLayoutEventSpace != aEventType)

                    {

                    iPredictiveWnd->MoveTo((EEventStdKeyUpArrow != aEventType)?

                                        CPeninputJapanesePredictiveWnd::EScrollDown : CPeninputJapanesePredictiveWnd::EScrollUp);

                    }

                else if (EStatusPredictiveTransitoryInputWithNoChar == iStatus && EPeninputLayoutEventSpace == aEventType)

                    {  // only by space button on vkb peninput

                    iStatus = EStatusInitial;

                    UpdateContextFieldL();

                    iUiLayout->SignalOwner(ESignalKeyEvent,aEventData);

                    }

                else

                    {

                    iPtiEngine->HandleCommandL(

                                 (EEventStdKeyUpArrow != aEventType)? EPtiCommandUserActionConvert : EPtiCommandUserActionPrevious);

                    if (EStatusCandidate == iStatus)   // not take place

                        {

                        iCandidateWnd->MoveToL((EEventStdKeyUpArrow != aEventType)?

                                                CPeninputJapaneseCandidateWnd::EScrollDown : CPeninputJapaneseCandidateWnd::EScrollUp);

                        }

                    else

                        {

                        iStatus = (EStatusConversion == iStatus)? EStatusCandidate : EStatusConversion;

                        }

                    UpdateContextFieldL();

                    }

                }

            break;

        case EPeninputLayoutEventTab:

            if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                {

                iStatus = EStatusCompleteAll;   // wait for SetEditorTextL()

                iUiLayout->SignalOwner(ESignalKeyEvent,aEventData);

                }

            break;

        case EEventCancelHiraganaKanji:    // Cancel:from UiLayout   not used

            ClearTextL();

            break;

        case EEventStdKeyLeftArrow:

        case EEventStdKeyRightArrow:

            if (EStatusTransitoryInput == iStatus)

                {

                TInt pos = -1;

                iPtiEngine->HandleCommandL(

                             (EEventStdKeyLeftArrow == aEventType)? EPtiCommandUserActionLeft : EPtiCommandUserActionRight);

                const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();

                if (data)

                    {

                    pos = data->CursorPosition();

                    }

                if(0 <= pos)

                    {

                    iInputContextField->SetCursorPosition(pos);

                    }

                }

            else if (EStatusPredictiveTransitoryInput == iStatus || EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                {

                iPredictiveWnd->MoveTo((EEventStdKeyLeftArrow != aEventType)?

                                            CPeninputJapanesePredictiveWnd::EScrollRight : CPeninputJapanesePredictiveWnd::EScrollLeft);

                }

            else if (EStatusConversion == iStatus || EStatusCandidate == iStatus)

                {

                iStatus = EStatusChangeDivision;

                }

            if (EStatusChangeDivision == iStatus)

                {

                iPtiEngine->HandleCommandL(

                             (EEventStdKeyLeftArrow == aEventType)? EPtiCommandUserActionShorten : EPtiCommandUserActionLengthen);

                UpdateContextFieldL();

                }

            break;

        case EEventIcfPointerUp:  // from ContextField

            if (EStatusConversion == iStatus || EStatusCandidate == iStatus)

                {

                iPtiEngine->HandleCommandL(EPtiCommandUserActionShorten);

                iPtiEngine->HandleCommandL(EPtiCommandUserActionLengthen);

                iStatus = EStatusChangeDivision;

                UpdateContextFieldL();

                }

            else if (EStatusTransitoryInput == iStatus

                   || EStatusPredictiveTransitoryInput == iStatus

                   || EStatusPredictiveTransitoryInputWithNoChar == iStatus  // not take place

                   || EStatusChangeDivision == iStatus)

                {

                TInt pos = -1;

                TInt cursorPosition = *((TInt*)aEventData.Ptr());

                const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();

                if (data)

                    {

                    pos = data->CursorPosition();

                    if (EStatusChangeDivision == iStatus)

                        {

                        if (data->NumberOfPhrase() > 0)

                            {

                            TPtrC8 clauseChar = data->LengthOfPhrase();

                            pos = clauseChar[0];

                            }

                        }

                    }

                if(0 <= pos)

                    {

                    TInt posDiff = cursorPosition - pos;

                    if(posDiff)

                        {

                        TPtiEngineCommand cmd;

                        if (EStatusChangeDivision == iStatus)

                            {

                            cmd = (posDiff < 0)? EPtiCommandUserActionShorten : EPtiCommandUserActionLengthen;

                            }

                        else

                            {

                            cmd = (posDiff < 0)? EPtiCommandUserActionLeft : EPtiCommandUserActionRight;

                            }

                        if (posDiff < 0)

                            {

                            posDiff = -posDiff;

                            }

                         while(posDiff > 0)

                            {

                            -- posDiff;

                            iPtiEngine->HandleCommandL(cmd);

                            }

                        }

                    if (EStatusChangeDivision == iStatus)

                        {

                        iPtiEngine->HandleCommandL(EPtiCommandUserActionConvert);

                        iStatus = EStatusConversion;

                        UpdateContextFieldL();

                        }

                    }

                }

            break;

		case EEventIcfCompleteAll:  // from ContextField

            {

            CompleteL();

            }

            break;

        case EEventICFSelectionChanged:  // from ContextField (when whithout transitory input)

            {

            }

            break;

        case EEventSetAppCursorSelection:  // from ContextField

            { // clear prediction pane

            if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                {

                iStatus = EStatusInitial;

                UpdateContextFieldL();

                }

            }

            break;

        default:

            break;

        }

    }

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

// CPeninputHiraganaKanji::HandleKeyEvent

// without implementation

// (other items were commented in a header).

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

EXPORT_C TBool CPeninputHiraganaKanji::HandleKeyEvent(const TRawEvent& aData)

    {

    TBool ret = EFalse;

    iPendingEvent = 0;

    if(EStatusComplete == iStatus || EStatusCompleteAll == iStatus

          || EStatusCompleteAllfromUiLayout == iStatus) // wait for SetEditorTextL from Editor

        {

        return ETrue;

        }

    const MPtiEngineCompositionDataInterface* data = iPtiEngine->CompositionData();

    if (!data)

        {

        return ret;

        }

    TPtrC text = data->ConvertingString();

    if (text.Length() > 0 || EStatusPredictiveTransitoryInputWithNoChar == iStatus)

        {

        TInt key = (aData.ScanCode() & 0x000000FF);

        TInt evetType = EPeninputLayoutEventEnter;

        TInt repeat = 0;

        switch(key)

            {

            case EKeyUpArrow:

            case EStdKeyUpArrow:        /* 0x10 */

                {

                evetType = EEventStdKeyUpArrow;

                ret = ETrue;

                repeat = 1;

                }

                break;

            case EKeyDownArrow:

            case EStdKeyDownArrow:

                {

                evetType = EEventStdKeyDownArrow;

                ret = ETrue;

                repeat = 1;

                }

                break;

            case EKeyLeftArrow:

            case EStdKeyLeftArrow:      /* 0x0e */

                {

                evetType = EEventStdKeyLeftArrow;

                ret = ETrue;

                repeat = 1;

                }

                break;

            case EKeyRightArrow:

            case EStdKeyRightArrow:     /* 0x0f */

                {

                evetType = EEventStdKeyRightArrow;

                ret = ETrue;

                repeat = 1;

                }

                break;

            case EKeyOK:

            case EStdKeyDevice3:        /* 0xA7 */

            case EStdKeyEnter:          /* 0x03 */

            case EStdKeyNkpEnter:       /* 0x88 */

                {

                evetType = EPeninputLayoutEventEnter;

                ret = ETrue;

                }

                break;

            case EKeyBackspace:

            case EStdKeyBackspace:      /* 0x01 */

                {

                evetType = EPeninputLayoutEventBack;

                ret = ETrue;

                repeat = 1;

                }

                break;

            case EStdKeyEscape:         /* 0x04 */

                {

                evetType = EPeninputLayoutEventBack;

                ret = ETrue;

                }

                break;

            case EStdKeyTab:         /* 0x02 */

                {

                evetType = EPeninputLayoutEventTab;

                ret = ETrue;

                }

                break;

            case EStdKeySpace:         /* 0x05 */

                {

                if (EStatusPredictiveTransitoryInputWithNoChar == iStatus)

                    {

                    iStatus = EStatusInitial;

                    TRAP_IGNORE(UpdateContextFieldL());  // not Leave

                    }

                else

                    {

                    evetType = EPeninputLayoutEventSpace;

                    ret = ETrue;

                    }

                }

                break;

            default:

                break;

            }

        if(ret && TRawEvent::EKeyDown == aData.Type())

            {

            iPendingEvent = evetType;

            iRepeat = repeat;

            }

        if(TRawEvent::EKeyUp == aData.Type())

            {

            CancelRepeat();

            }

        }

    return ret;

    }

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

// CPeninputHiraganaKanji::HandlePendingEventL

// (other items were commented in a header).

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

EXPORT_C TBool CPeninputHiraganaKanji::HandlePendingEventL()

    {

    if (iPendingEvent)

        {

        if (EPeninputLayoutEventBack == iPendingEvent)

            {

            iUiLayout->HandleControlEvent(EPeninputLayoutEventBack, reinterpret_cast<CFepUiBaseCtrl*>(this), KNullDesC);

            }

        else  // up/down/left/right arrow

            {

            HandleControlEventJpL(iPendingEvent, KNullDesC);

            }

        if (iRepeat)

            {

            iLongPressTimer->SetTimer(KLongPressInterval);