/*

* 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 of the hwr layout

*

*/

// system includes

#include <peninputhiraganakanji.h>       // hiraganakanji

#include <peninputuistatemgr.h>    // use ui state mgr

#include <peninputdataconverter.h>

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

#include <peninputcommonlayoutglobalenum.h>  // EPeninputLayoutEventEnter

#include <peninputeventjp.h>

#include <AknFepGlobalEnums.h> //define TWidthChar

#include <PtiEngine.h>

#include <peninputjapanesecandidatewnd.h>

#include <peninputjapanesepredictivewnd.h>

// user includes

#include "peninputhwrboxlayout.h"

#include "peninputhwrboxuistatetype.h"         // UI state

#include "peninputhwrboxwindow.h"        // use hwr window, which derived from base window

#include "peninputhwrboxdatamgr.h"       // use data mgr

#include "peninputhwrboxuistatestandby.h"

#include "peninputhwrboxuistatestandbyjp.h"

#include "peninputhwrboxuistatewithtransitorychars.h"

#include "peninputhwrboxuistatepenstandby.h"

#include "peninputhwrboxuistatepenbeginwriting.h"

#include "peninputhwrboxuistatepenendwriting.h"

#include "peninputhwrboxuistatepencandidateselecting.h"

#include "peninputhwrevent.h"

#include "peninputhwrboxgroup.h"

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

#include <PeninputHwrStrokeLogConst.h>

#endif // __PENINPUT_HWR_STROKE_LOG_ON

// constant definition

const TInt KMaxCandidateLen = 128;

const TUint16 KBackRep = 0x2408;

const TUint16 KEnterRep = 0xF801;

const TUint16 KSpaceRep = 0xF800;

const TInt KDelay = 100000; //1/10 second

const TInt KPeninputBufLen = 16;

const TInt KPeninputBufLen8 = 8;

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

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

// CPeninputHwrBoxLayout::NewL

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

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

//

CPeninputHwrBoxLayout* CPeninputHwrBoxLayout::NewL(MLayoutOwner* aLayoutOwner,

                                         const TAny* aInitData)

    {

    CPeninputHwrBoxLayout* self = new (ELeave) CPeninputHwrBoxLayout(aLayoutOwner);

    CleanupStack::PushL(self);

    self->ConstructL(aInitData);

    CleanupStack::Pop(self);

    return self;

    }

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

// CPeninputHwrBoxLayout::~CPeninputHwrBoxLayout

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

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

//

CPeninputHwrBoxLayout::~CPeninputHwrBoxLayout()

    {

    delete iHiraganaKanji;

    delete iKeyEventAsync;

    delete iKeyEventClearAsync;

    delete iPointerEventAsync;

    delete iUiStatePenMgr;

    delete iSubmitText;

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    if (iLogger.LogValid())

        {

        iLogger.CloseLog();

        }

    iLogger.Close();

#endif // __PENINPUT_HWR_STROKE_LOG_ON

    }

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

// CPeninputHwrBoxLayout::HandleEventL

// handle event from window server

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

//

TBool CPeninputHwrBoxLayout::HandleEventL(TEventType aType, const TAny* aData)

    {

    TRawEvent event=*((TRawEvent*)aData);

    CFepUiBaseCtrl* ctrl = NULL;

    if(ERawEvent == aType)

        {

        if (TRawEvent::EButton1Down == event.Type() && iHiraganaKanji)

            {

            iHiraganaKanji->CancelRepeat();

            }

        // DropDownList expanded and PointerDown on drawing area ---> cancel input and to StandBy

        if (iExpanded

            && TRawEvent::EButton1Down == event.Type()

            && iUiStatePenMgr->CurrentUiState() == iUiStatePenMgr->GetUiState(EPeninputHwrUiStatePenCandidateSelecting)

            && iDropdownList

            && iHwrWindow->BoxGroup())

            {

            TPoint point = event.Pos() - Position ();

            if (!iDropdownList->Rect().Contains(point)

                && iHwrWindow->BoxGroup()->Rect().Contains(point))

                {

                ClearInputToPenStandByL();

                return ETrue;

                }

            }

        if(TRawEvent::EButton1Up == event.Type())

            {

            ctrl = RootControl()->CtrlCapPointer();

            }

        }

    TBool handled = CPeninputCommonLayout::HandleEventL(aType,aData);

    // if dropdownlist expanded, capture off

    // as the dropdownlist is the 1st control in the clientpane controlgroup, capture is not need.

    if (TRawEvent::EButton1Up == event.Type() && !ctrl)

        {

        CFepUiBaseCtrl* capture = RootControl()->CtrlCapPointer();

        if (capture && capture->ControlId() == EPeninutWindowCtrlIdDropDownList)

           {  // dropdownlist expanded

           iDropdownList = capture;

           capture->CapturePointer(EFalse);

           SetCapturePointerEventAgain(); // capture for transitory input on

           HandleControlEvent(EPeninputLayoutHwrEventDropDownListExpanded, capture, KNullDesC);

           }

        }

    // if a control do capture off, capture for transitory input on.

    if (ctrl && !RootControl()->CtrlCapPointer())

        {

        SetCapturePointerEventAgain();

        }

    return handled;

    }

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

// CPeninputHwrBoxLayout::HandleCommand

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

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

//

TInt CPeninputHwrBoxLayout::HandleCommand(TInt aCmd, TUint8* aData)

    {

    // Handle command from fep or IME to this layout

    TUint* data = (TUint*) aData;

    switch ( aCmd )

        {

        case ECmdPenInputPermittedRange:  // different from common layout

            // this command comes after ECmdPenInputJapaneseSetting

            if (iDataMgr)

                {

                // in SetData, SetPermittedRanges() and SetCharacterRangePopupLare() called.

                SetData(EPeninputDataTypePermittedRange, aData);

                }

            break;

        case ECmdPenInputLanguage:

            {

            CPeninputCommonLayout::HandleCommand(aCmd, aData);

            }

            break;

        case ECmdPenInputWindowOpen:

            if (iHwrWindow)

                {

                iHwrWindow->Opened();

                iLayoutWindow->Hide(EFalse);  // before Hide Check or Change, parent controlgroup should be Hide Off.

                TInt curRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypeCurrentRange));

                TBool currHide = iHwrWindow->PredictiveWindow()->Hiden();

                TBool newHide = ETrue;

                if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Predictive()

                              && static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Conversion()

                              &&  ERangeHiraganaKanji == curRange)

                    {

                    newHide = EFalse;

                    }

                if (newHide && !currHide || !newHide && currHide)

                    {

                    iHwrWindow->PredictiveWindow()->Hide(newHide);

                    iHwrWindow->SizeChanged(ETrue);

                    }

                CPeninputCommonLayout::HandleCommand( aCmd, aData );

                if (*data != EPenInputOpenManually && Position() == TPoint(0,0))

                    {  // position is not yet set.(English --> Japanese)

                    SendEventToWindow(EPeninputLayoutEventMovePosition, NULL, KNullDesC);

                    }

                iHwrWindow->ICFEnableRegionUpdating();  // ICF::OnActivate()

                }

            ToPenStandBy();

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    if (iLogger.Handle())

        {

        if (iLogger.LogValid())

            {

            iLogger.CloseLog();

            }

        // Generate file name based on date.

        TTime time;

        time.HomeTime();

        TDateTime datetime = time.DateTime();

        TBuf<KHwrStrokeLogFileNameMaxLen> name;

        name.Format(KHwrStrokeLogFileExt(),

            datetime.Year(), TInt(datetime.Month()+1), datetime.Day()+1,

            datetime.Hour(), datetime.Minute(), datetime.Second());

        // Open(or create) log file

        iLogger.CreateLog( KHwrStrokeLogDir(), name, EFileLoggingModeAppend);

        // Disable date and time

        iLogger.SetDateAndTime(EFalse, EFalse);

        // Write log

        iLogger.Write(KHwrStrokeLogOpen());

        WriteHwrStrokeLogRange();

        }

#endif // __PENINPUT_HWR_STROKE_LOG_ON

            break;

        case ECmdPenInputWindowClose:

            SendEventToWindow(EPeninputLayoutEventCloseCharacterRange, NULL, KNullDesC);

            HiraganaKanjiCompleteAll();

            CPeninputCommonLayout::HandleCommand( aCmd, aData );

            UiStateMgr()->SetCurrentUiState( EPeninputHwrUiStateNone );

            Initialize();

            SetCapturePointerEvent(EFalse);

            iHwrWindow->Closed();

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    if (iLogger.LogValid())

        {

        iLogger.Write(KHwrStrokeLogClose());

        iLogger.CloseLog();

        }

#endif // __PENINPUT_HWR_STROKE_LOG_ON

            break;

        case ECmdPenInputRange:  // different from common layout:control. ptiEngine.

            {

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    iLogOff = 1;

#endif

            // this command comes after ECmdPenInputJapaneseSetting, ECmdPenInputPermittedRange

            if (iLayoutWindow)

                {

                iHwrWindow->ICFDisableRegionUpdating();  // ICF::OnDeActivate()

                iLayoutWindow->Hide(EFalse);  // before Hide Check or Change, parent controlgroup should be Hide Off.

                }

            if (iDataMgr)

                {

                TUint range = TranslateRangeHullHalf(*data);

                TUint8* rangedata = reinterpret_cast<TUint8*>(&range);

                // SetData(SetPremaryRange) and SizeChangedForBaseWindow and ChangeClientLayout

                CPeninputCommonLayout::HandleCommand( aCmd, rangedata );

                iRangeOrg = range;

                TInt permittedRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypePermittedRange));

                if (permittedRange & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana))

                    {

                    TInt index = 0;

                    if (range == ERangeEnglish || range == ERangeFullWidthEnglish)

                        {

                        index = 2;  // see CPeninputHwrBoxDataMgr::SetCharacterRangePopupL()

                        }

                    if (range == ERangeNumber || range == ERangeFullWidthNumeric)

                        {

                        index = (permittedRange & (ERangeEnglish | ERangeFullWidthEnglish))? 3:2;

                                                 // see CPeninputHwrBoxDataMgr::SetCharacterRangePopupL()

                        }

                    if (index)

                        {

                        TPtrC dataPtr;

                        dataPtr.Set(reinterpret_cast<TUint16*>(&index),sizeof(TInt)/sizeof(TUint16));

                        HandleControlEvent(EPeninputLayoutEventRange,NULL,dataPtr);  // call DoSetCurrentRange()

                        }

                    else

                        {

                        DoSetCurrentRange();

                        }

                    }

                else

                    {

                    DoSetCurrentRange();

                    }

                }

            }

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    iLogOff = 0;

#endif

            break;

        case ECmdPenInputJapaneseSetting:  // Japanese setting information

            // this command comes before ECmdPenInputPermittedRange, ECmdPenInputRange

            if (iDataMgr)

                {

                iDataMgr->Reset();

                TUint val = *data;

                TInt sctDimmFlag = (val & EPenInputJapaneseSettingLunchSCT)? 0: 1;

                TPtr ptr((TUint16*)&sctDimmFlag, sizeof(TInt)/sizeof(TUint16));

                SendEventToWindow(EEventSetDimmedSctBtn, NULL, ptr);

                static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetFullHalf(

                                (val & EPenInputJapaneseSettingCharacterWidth)? 1: 0);

                static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetPredictive(

                                (val & EPenInputJapaneseSettingPredictive)? ETrue: EFalse);

                static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetConversion(

                                (val & EPenInputJapaneseSettingConversion)? ETrue: EFalse);

                static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetClear(

                                (val & EPenInputJapaneseSettingDeletingDirection)? 1: 0);

                }

            break;

        case ECmdPenInputEnableSettingBtn:

            iHwrWindow->SetEnableSettingBtnJp(*data);

            break;

        case ECmdPenInputSendEditorTextAndCurPos:

            CFepUiLayout::HandleCommand( aCmd, aData );

            break;

        default:

            CPeninputCommonLayout::HandleCommand( aCmd, aData );

            break;

        }

    return KErrNone;

    }

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

// CPeninputHwrBoxLayout::HandleControlEvent

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

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

//

void CPeninputHwrBoxLayout::HandleControlEvent(TInt aEventType, CFepUiBaseCtrl* aCtrl, const TDesC& aEventData)

    {

    // Handle event from control

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

    TBool handled = EFalse;

    if (EEventDraggingEnd == aEventType)

        {

        CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);

        }

#ifdef __PENINPUT_HWR_STROKE_LOG_ON

    if (EPeninputLayoutEventBack == aEventType)

        {

        WriteHwrStrokeLogClear();

        }

    if (EPeninputLayoutHwrEventCandidateSelected == aEventType && iLogger.LogValid())

        {

        if (aEventData.Length() > 1)

            {

                    //get the candidate index

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

            iLogger.WriteFormat(KHwrStrokeLogSelected(), cellNo);

            }

        }

#endif // __PENINPUT_HWR_STROKE_LOG_ON

    if (iUiStatePenMgr != NULL)

        {

        handled = HandleControlEventPen(aEventType, aCtrl, aEventData);

        }

    if (handled)

        {

        return;

        }

    //deal with the event from all controls in layout

    switch (aEventType)

        {

        case EPeninputLayoutEventClose:

        case EPeninputLayoutEventOption:

        case EPeninputLayoutEventToVkb:

            HiraganaKanjiCompleteAll();  // call ToPenStandBy()

            SetCapturePointerEvent(EFalse);

            if (EPeninputLayoutEventClose == aEventType)

                {

                Initialize();  //jump to init state

                }

            if (EPeninputLayoutEventToVkb == aEventType)

                {

                TBuf<KPeninputBufLen8> buf;

                TBool switchByMode = ETrue;

                TInt mode = EPluginInputModeVkb;

                CPeninputDataConverter::CombinationToDesc( switchByMode, 

                                                                 mode, buf );

                SignalOwner( ESignalLayoutUIChanged, buf );

                }

            else

                {

                CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, aEventData);

                }

            break;

        case EPeninputLayoutEventSct:

            HiraganaKanjiCompleteAll();

            SetCapturePointerEvent(EFalse);

            SignalOwner(ESignalHwNotifySctPopup);

            break;

        case EPeninputLayoutEventSwitchLanguage: // nop

            break;

        case EPeninputLayoutEventRange:  // from character range popup or when accept ECmdPenInputRange command

            {

            TInt permittedRange = CPeninputDataConverter::AnyToInt(RequestData(EPeninputDataTypePermittedRange));

            TInt currentRange = CPeninputDataConverter::AnyToInt( RequestData( EPeninputDataTypeCurrentRange ) );

            TInt range = currentRange;

            TInt deActive = 0;   // 0:none 1:ICF 2:display off

            static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetCurrentCharacterRangeIndex(*data);

            switch(static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->CharacterRangeId())

                {

                case EPeninutCharacterRangeIdAll:

                    if (permittedRange & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana))

                        {

                        if (!(range & (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana)))

                            {

                            range = (permittedRange & ERangeHiraganaKanji)? ERangeHiraganaKanji : ERangeKatakana;

                            }

                        }

                    break;

                case EPeninutCharacterRangeIdKanaKanji:

                    permittedRange &= (ERangeHiraganaKanji | ERangeKatakana | ERangeFullWidthKatakana);

                    if (!(permittedRange & range))

                        {

                        range = (permittedRange & ERangeHiraganaKanji)? ERangeHiraganaKanji : ERangeKatakana;

                        }

                    break;

                case EPeninutCharacterRangeIdLatin:

                    permittedRange &= (ERangeEnglish | ERangeFullWidthEnglish);

                    range = ERangeEnglish;

                    break;

                case EPeninutCharacterRangeIdNumber:

                    permittedRange &= (ERangeNumber | ERangeFullWidthNumeric);

                    range = ERangeNumber;

                    break;

                default:

                    break;

                }

            static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->SetPermittedRanges(permittedRange);

            range = TranslateRangeHullHalf(range);

            if (!(range & permittedRange))

                {

                range = iRangeOrg;

                }

            if (aCtrl)  // from character range popup

                {

                TBool currHide = iHwrWindow->PredictiveWindow()->Hiden();

                TBool newHide = ETrue;

                if (static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Predictive()

                                  && static_cast<CPeninputHwrBoxDataMgr*>(iDataMgr)->Conversion()

                                  &&  ERangeHiraganaKanji == range)

                    {

                    newHide = EFalse;

                    }

                if (newHide && !currHide || !newHide && currHide)

                    {

                    LayoutOwner()->Hide(ETrue);   // display off

                    deActive = 2;

                    iHwrWindow->PredictiveWindow()->Hide(newHide);

                    iHwrWindow->SizeChanged(ETrue);

                    }

                else

                    {

                    iHwrWindow->ICFDisableRegionUpdating();  // ICF::OnDeActivate()

                    deActive = 1;

                    }

                iHwrWindow->CharacterRangeWindow()->HidePopup();

                }

            if (aCtrl && range != currentRange)  // from character range popup

                {

                // SetData(SetPremaryRange) and Sendkey( ESignalRange,...)

                TPtrC rangeptr((TUint16*)(&range), sizeof(TInt)/sizeof(TUint16));

                CPeninputCommonLayout::HandleControlEvent(aEventType, aCtrl, rangeptr);

                if (ERangeEnglish != range && ERangeNumber != range)

                    {

                    TInt native = ERangeNative;

                    TBuf<KPeninputBufLen> buf;

                    CPeninputDataConverter::CombinationToDesc( native, range, buf );

                    Sendkey( ESignalRange, buf );

                    }

                }

            else

                {

                SetData(EPeninputDataTypeCurrentRange, &range);

                }

            DoSetCurrentRange();

            if (deActive == 2)

                {

                LayoutOwner()->Hide(EFalse);   // display on

                }

            else if (deActive == 1)

                {

                iHwrWindow->ICFEnableRegionUpdating();  // ICF Cursor On

                }

            }

            break;

        // from HiraganaKanji

        case EEventHiraganaKanjiWithTransitoryChars2Standbyjp:

            if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))

                {

                UiStateMgr()->SetCurrentUiState(EPeninputHwrUiStateStandbyjp);

                SetCapturePointerEvent(EFalse);

                ToPenStandBy();

                }

            break;

        // from HiraganaKanji

        case EEventHiraganaKanjiWithoutTransitoryChars:

            if (UiStateMgr() && UiStateMgr()->CurrentUiState() == UiStateMgr()->GetUiState(EPeninputHwrUiStateWithTransitoryChars))

                {

                SetCapturePointerEvent(EFalse);

                }

            break;

        case EEventVirtualKeyUp:

            if ( UiStateMgr()->CurrentUiState()

            && !static_cast<CPeninputHwrBoxUiState*>(UiStateMgr()->CurrentUiState())->HandleControlEvent(aEventType,aEventData) )

                {

                SetCapturePointerEvent(ETrue);

                HiraganaHandleControlEventJp(aEventType, aEventData);

                }

            break;

        case EPeninputLayoutEventBack: