/*

* 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 finger hwr UiLayout

*

*/

//SYSTEM INCLUDES

#include <bautils.h>

#include <coemain.h>

//FEP Includes

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <peninputlayoutchoicelist.h>

#include <settingsinternalcrkeys.h>

#include <centralrepository.h>

#include <peninputlayoutvkb.h>

#include <AknFepGlobalEnums.h>

#include <peninputcmdparam.h>

#include <peninputdropdownlist.h>

#include <peninputlayoutmultilineicf.h>

//USER INCLUDES

#include "peninputfingerhwrdatastore.h"

#include "peninputfingerhwrstatemanager.h"

#include "peninputfingerhwrevent.h"

#include "peninputfingerhwrlayout.h"

#include "peninputfingerhwrcontrolid.h"

#include "peninputfingerhwrwnd.h"

#include "peninputfingerhwrcn.rsg"

//CONST DEFINATION

_LIT( KFSHWRRssFile, "\\resource\\peninputfingerhwrcn.rsc" );

const TUint8 KTempBufSize = 8;

const TUint8 KIntLen = sizeof(TInt)/2;

const TUint8 KIntSize = sizeof(TInt);

const TInt16 KEmotionKeyMark = 0xFFFE;

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

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

// Symbian Constructor

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

//

CPeninputFingerHwrLayout* CPeninputFingerHwrLayout::NewL( 

    MLayoutOwner* aLayoutOwner, const TAny* aInitData )

    {

    CPeninputFingerHwrLayout* self = new( ELeave ) CPeninputFingerHwrLayout( 

            aLayoutOwner );

    CleanupStack::PushL( self );

    self->ConstructL( aInitData );

    CleanupStack::Pop( self ); //self

    return self;

    }

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

// handle the command from Fep.

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

//

TInt CPeninputFingerHwrLayout::HandleCommand( const TInt aCmd, TUint8* aData )

    {

    TInt ret = KErrUnknown;

    TRAPD(err, ret = HandleCommandL( aCmd, aData ) );

    if ( err )

        {

        return KErrUnknown;

        }

    else

        {

        return ret;

        }

    }

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

// handle the command from Fep.

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

//

TInt CPeninputFingerHwrLayout::HandleCommandL( const TInt aCmd, TUint8* aData )

    {

    if ( CFepUiLayout::HandleCommand( aCmd, aData ) == KErrNone )

        {

        return KErrNone;

        }

    TInt ret = KErrUnknown;

    switch ( aCmd )

        {

        case ECmdPenInputEditorNumericKeyMap:

            {

            iDataStore->SetNumberMode( *(TAknEditorNumericKeymap*)aData );

            OnNumMappingChangedL();

            ret = KErrNone;

            }

            break;

        case ECmdPenInputEditorCustomNumericKeyMap:

            {

            TInt len = *( TInt* )( aData - KIntSize );

            TPtrC16 keymapRes( (TUint16*)aData, len / 2 );

            iDataStore->SetCustomNumberModeL( keymapRes );

            OnNumMappingChangedL();

            ret = KErrNone;

            }

            break;

        case ECmdPenInputPermittedRange:

            {

            TInt ranges = *(TInt*)aData;

            iDataStore->SetPermittedRanges( ranges );

            iHwrWnd->SetPermittedRanges( ranges );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputLanguage:

            {

            TInt language = *( TInt* )aData;

            iDataStore->SetLanguageL( language );

            iHwrWnd->SetInputLanguage( language );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputRange:

            {

            TInt range = *( TInt* )aData;

            iDataStore->SetPrimaryRange( range );

            range = iDataStore->CurrentRange();

            iHwrWnd->TryToChangeCharRange( range );

            TBuf<KIntLen> buf;

            buf.Append( reinterpret_cast<TText*>( aData ), KIntLen );

            SignalOwner( ESignalRange, buf );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputPermittedCase:

            {

            TInt cs = *( TInt* )aData;

            iDataStore->SetPermittedCases( cs );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputCase:

            {

            TInt cs = *( TInt* )aData;

            iDataStore->SetCase( cs );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputWindowOpen:

            {

            if( !iIsOpenFingerHWR )

                {

                iDataStore->GetKeyboardType();

                iDataStore->SetKeyboardToQwerty();

                }

            LayoutOwner()->Hide( EFalse );

            RootControl()->UpdateValidRegion( NULL, EFalse );

            TRect hwrRect = iHwrWnd->WritingBoxRect();

            TSize hwrSize = hwrRect.Size();

            iDataStore->SetInputAreaSize(hwrSize);

            iDataStore->SetScreenSize(hwrSize);

            ChangeCurStateManagerToStandby();

            iIsOpenFingerHWR = ETrue;

            ret = KErrNone;

            }

            break;

        case ECmdPenInputWindowClose:

            {

            iIsOpenFingerHWR = EFalse;

            iDataStore->ResetKeyboardType();

            LayoutOwner()->Hide( ETrue );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputSetTextAlignment:

            {

            iHwrWnd->SetTextAlignmentL( *aData, ELangPrcChinese );

            ret = KErrNone;            

            }

            break;

        case ECmdPenInputSetPromptText:

            {

            iHwrWnd->SetPromptTextL( aData );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputDimArrowKeys:

            {

            TBool IsDimArrowKeys = *aData;

            iHwrWnd->DimArrowKeys( IsDimArrowKeys );

            ret = KErrNone;

            }

            break;

        case ECmdPenInputCharacterPreview:

            {

            iHwrWnd->ShowBubble(*aData);    

            }

            break;

        case ECmdPenInputEnableSettingBtn:    

            {

            TBool isEnableSetting = *aData;

            iHwrWnd->SetEnableSettingBtn(isEnableSetting);

            }

            break;  

        default:

            break;

        }

    return ret;

    }

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

// handle size changing event.

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

//

TInt CPeninputFingerHwrLayout::SizeChanged( const TAny* /*pData*/ )

    {

    //Handle size change event

    SetRect( TRect( TPoint( 0, 0 ), ScreenSize() ) );

    TRAP_IGNORE( iHwrWnd->SizeChangedL( EFalse ) );

    return KErrNone;

    }

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

// Handle editor text coming.

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

//

TInt CPeninputFingerHwrLayout::OnAppEditorTextComing( 

    const TFepInputContextFieldData& aData )

    {

    if ( iHwrWnd )

        {

        TRAPD( err, iHwrWnd->SetEditorTextL( aData ) );

        return err;

        }

    return KErrNone;

    }

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

// Handle application info change.

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

//

void CPeninputFingerHwrLayout::HandleAppInfoChange( const TDesC& aInfo,

    TPeninputAppInfo aType )

    {

    if ( aType == EAppIndicatorMsg )

        {

        TRAP_IGNORE( iHwrWnd->SetBubbleTextL( aInfo ) );

        }

    }

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

// Called by owner when the system resource changed event.

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

//

TInt CPeninputFingerHwrLayout::OnResourceChange( TInt aType )

    {

    CFepUiLayout::OnResourceChange( aType );

    if ( aType == KAknsMessageSkinChange )

        {

        //Do other things when skin change

        TInt newValue = GetPenTrailColor();

	    SetBoxPenColor(newValue);        

        }

    return KErrNone;

    }

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

// get the peninput ui type.

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

//

TInt CPeninputFingerHwrLayout::PenInputType()

    {

    return EPluginInputModeFingerHwr;

    }

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

// Called by owner when the layout is going to be hidden.

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

//

void CPeninputFingerHwrLayout::OnDeActivate()

    {

    iIsOpenFingerHWR = EFalse;

    iDataStore->ResetKeyboardType();

    //cancel writing

    iHwrWnd->CancelWriting();

    // Bring the expandable dropdown list back to right level

    iHwrWnd->PredictiveList()->BringToBack();

    //cancel range selector

    if ( iHwrWnd->RangeDropListVisible() )

        {

        iHwrWnd->CancelRangeDropList();

        }

    if(iHwrWnd->CurrentCharRange() != EFingerHwrSymbolRange)

        {

        iHwrWnd->UpdateLayout( ETrue );

        }

    CFepUiLayout::OnDeActivate();

    }

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

// handle control event.

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

//

void CPeninputFingerHwrLayout::HandleControlEvent( TInt aEventType,

    CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

    {

    TRAP_IGNORE( HandleControlEventL( aEventType, aCtrl, aEventData ) );

    }

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

// handle control event.

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

//

void CPeninputFingerHwrLayout::HandleControlEventL( TInt aEventType,

    CFepUiBaseCtrl* aCtrl, const TDesC& aEventData )

    {

    switch ( aEventType )

        {

        case EEventButtonDown:

            {

            OnCtrlButtonDownL( aEventType, aCtrl, aEventData );

            }

            break;

        case EEventButtonUp:

            {

            OnCtrlButtonUpL( aEventType, aCtrl, aEventData );

            }

            break;

        case EEventChoiceSelected:

            {

            OnImeSelected( aEventType, aCtrl, aEventData );

            }

            break;

        case EEventHwrCharacterTimerOut:

            {

            OnHwrCharacterFinishedL();

            }

            break;

        case EEventHwrStrokeStarted:

            {

            OnHwrStrokeStartedL();

            }

            break;

        case EEventHwrStrokeFinished:

            {

            OnHwrStrokeFinishedL();

            }

            break;

        case EHwrEventKeyBack:

            {

            OnBackspaceClickedL();

            }

            break;

        case EHwrEventNavKeyClicked:

            {

            OnRepButtonClickedL( aCtrl, aEventData );

            }

            break;

        case EEventVirtualKeyDown:

            {

            OnVirtualKeyDownL( aCtrl, aEventData );

            }

            break;

        case EEventVirtualKeyUp:

            {

            OnVirtualKeyUpL( aCtrl, aEventData );

            }

            break;

        case EHwrEventCandidateSelected:

            {

            OnCandidateSelectedL( aCtrl, aEventData );

            }

            break;

        case EHwrEventPredictiveSelected:

            {

            OnPredictSelectedL( aCtrl, aEventData );

            }

            break;

        case EHwrEventGetNextCandidatePage:

            {

            OnCandidateWndEventL();

            }

            break;

        case EEventIcfPointerUpEvent:

            {

            OnIcfClicked();

            }

            break;

        default:

            break;

        }

    }

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

// Get the data stroe object.

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

//

CPeninputFingerHwrDataStore& CPeninputFingerHwrLayout::DataStore()

    {

    return *iDataStore;

    }

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

// Delete the previous charcode and submit the new one

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

//

void CPeninputFingerHwrLayout::Replace( const TDesC& aOldCharCode,

    const TDesC& aNewCharCode, const TBool aIsPart )

    {

    // user tries to correct the previous selection

    // Delete the previous character and append the new one

    HBufC* newCharBuf = HBufC::New( aNewCharCode.Length() + KIntLen );

    if ( newCharBuf )

        {

        TInt len = aOldCharCode.Length();

        if(len == 0 )

            {

            delete newCharBuf;

            return;

            }

        newCharBuf->Des().Append( ( TUint16* )&len, KIntLen );

        newCharBuf->Des().Append( aNewCharCode );

        if ( aIsPart )

            {

            SignalOwner( ESignalReplacePartText, *newCharBuf );

            }

        else

            {

            SignalOwner( ESignalReplaceText, *newCharBuf );

            }

        delete newCharBuf;

        }

    }

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

// Submit string to layout owner.

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

//

void CPeninputFingerHwrLayout::SubmitStringToFep( const TDesC& aCharCode )

    {

    SignalOwner( ESignalKeyEvent, aCharCode );

    }

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

// Submit char to layout owner.

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

//

void CPeninputFingerHwrLayout::SubmitCharToFep( const TInt aCharCode )

    {

    TBuf<1> buf;

    buf.Append( aCharCode );

    SignalOwner( ESignalKeyEvent, buf );

    }

#ifdef RD_INTELLIGENT_TEXT_INPUT

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

// Submit start position to layout owner.

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

//

void CPeninputFingerHwrLayout::SubmitStartPosToFep( TBool aSetPosFlag )

    {

    TBuf<4> buf;

    TInt length = sizeof(TBool)/sizeof(TText);

    buf.Append( reinterpret_cast<TText*>( &aSetPosFlag ), length );

    SignalOwner( ESignalCharacterStart, buf );

    }

#endif 

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

// repository callback for settings.

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

//

TInt CPeninputFingerHwrLayout::HandleGSRepositoryCallBack( TAny* aPtr )

    {

    CPeninputFingerHwrLayout *self = static_cast<CPeninputFingerHwrLayout*>( aPtr );

    CAknFepRepositoryWatcher* watcher = self->iGSRepositoryWatcher;

    if ( watcher )

        {

        TInt newValue = self->GetNewValue( watcher, watcher->ChangedKey() );

        switch ( watcher->ChangedKey() )

            {

            case KSettingsWritingSpeed:

                {

                self->SetWritingSpeed( newValue );

                }

                break;

            case KSettingsPenWidth:

                {

                self->SetBoxPenSize( TSize( newValue, newValue ) );

                }

                break;

            case KSettingsPenColor:

                {

                self->SetBoxPenColor( newValue );