/*

* Copyright (c) 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:           

*      Provides the TAknFepInputStateStrokePhraseCreationBase definition.

*

*/

// System includes

#include <PtiEngine.h>

#include <avkon.rsg>

#include <PtiUserDicEntry.h>

#include <aknnotewrappers.h> //CAknWarningNote 

// User includes

#include "AknFepUIManagerStateInterface.h"

#include "AknFepUICtrlInputPane.h"

#include "AknFepUICtrlPinyinPopup.h"        //Pinyin phrase

#include "aknfepuictrleditpane.h"           //pinyin phrase creation

#include "AknFepUICtrlCandidatePane.h"

#include "AknFepManager.h"

#include "aknfepuiinputstatestrokephrasebase.h"

// Constant definition

const TInt KMinCnadidateCount = 1;

const TInt KMaxPhraseCount = 50;

const TInt KEnginePhoneticIndex = 1;

const TInt KMaxPhraseCreationCount = 7;

const TInt KMaxKeystrokeCount = 31;

const TInt KKey0Code = 48;

const TInt KKey1Code = 49;

const TInt KKey2Code = 50;

const TInt KKey3Code = 51;

const TInt KKey4Code = 52;

const TInt KKey5Code = 53;

const TInt KKey6Code = 54;

const TInt KAutoChangeState = 1;

const TInt KManualChangeState = 0; 

const TUint16 KDelimiter = 0x2022;

const TUint16 KStrokeKey1 = 0x4E00;

const TUint16 KStrokeKey2 = 0x4E28;

const TUint16 KStrokeKey3 = 0x4E3F;

const TUint16 KStrokeKey4 = 0x4E36;

const TUint16 KStrokeKey5 = 0x4E5B;

const TUint16 KStrokeKey6 = 0x003F;

const TUint16 KSegment = 0x0020;

_LIT( KMaxPhraseNote,"\x8BCD\x7EC4\x6700\x957F\x4E3A\x4E03\x5B57" );

const TKeyMap StrokeMap[] = 

    {

    {KDelimiter, KKey0Code},

    {KStrokeKey1, KKey1Code},

    {KStrokeKey2, KKey2Code},

    {KStrokeKey3, KKey3Code},

    {KStrokeKey4, KKey4Code},

    {KStrokeKey5, KKey5Code},

    {KStrokeKey6, KKey6Code}

    };

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

// TAknFepInputStateStrokePhraseCreationBase::TAknFepInputStateStrokePhraseCreationBase

// C++ default constructor

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

//

TAknFepInputStateStrokePhraseBase::TAknFepInputStateStrokePhraseBase(

    MAknFepUIManagerStateInterface* aOwner,

    MAknFepUICtrlContainerChinese* aUIContainer)

    :TAknFepInputStateChineseBase(aOwner, aUIContainer)

    {

    if ( iOwner->PtiEngine()->InputMode() != EPtiEngineStrokeByPhrase )

        {

        iOwner->PtiEngine()->SetInputMode( EPtiEngineStrokeByPhrase );

        }

    iOwner->PtiEngine()->SetCandidatePageLength( KMaxPhraseCount );

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    uiContainer->SetFepMan( iOwner->FepMan() );

    }

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

// TAknFepInputStateStrokePhraseBase::HandleKeyL

// Handle system key press event.

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

//

TBool TAknFepInputStateStrokePhraseBase::HandleKeyL( 

                                        TInt aKey, 

                                        TKeyPressLength aLength )

    {    

    switch( aKey )

        {

        case EKeyBackspace:

            {

            if ( CheckKeyNeedRepeat( aLength ) )

                {

                HandleKeyBackspaceL( aLength );

                }

            else

                {

                iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

                }

            break;

            }

        case EKeyUpArrow:

            {

            iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

            break;

            }

        case EKeyDownArrow:

            {

            if ( EStrokeSequenceEdit == iState )

                {

                if ( CheckFirstGroupStroke() )

                    {

                    UIContainer()->PinyinPopupWindow()->SetChangeState( ETrue );

                    iOwner->ChangeState( EEntry );

                    }

                }

            else

                {

                iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

                }

            break;

            }

        case EKeyLeftArrow:

            {

            if ( EStrokeSequenceEdit == iState )

                {

                MoveCursorLeft();

                }

            else

                {

                iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

                }

            break;

            }    

        case EKeyRightArrow:

            {

            if ( EStrokeSequenceEdit == iState )

                {

                MoveCursorRight();

                }

            else

                {

                iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

                }

            break;

            }

        case EKeyOK:

        case EKeyCBA1:

            {

            if ( CheckKeyNeedRepeat( aLength ) )

                {

                HandleKeyCBA1OrKeyOKL( aLength );

                }

            else

                {

                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

                }

            break;

            }

        case EKeyCBA2:

            {

            iOwner->FepMan()->TryCloseUiL();

            break;

            }

        default:

            {

            if ( ( EShortKeyPress == aLength ) && 

                ( iOwner->IsValidChineseInputKey( aKey ) ) )

                {

                HandleDefaultKeyL( aKey );

                }

            else

                {

                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

                }

            break;

            }

        }

    return ETrue;

    }

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

// TAknFepInputStateStrokePhraseBase::RefreshUI

// Update input window.

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

//

void TAknFepInputStateStrokePhraseBase::RefreshUI( TBool aRefresh )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    // get cursor position

    if ( aRefresh )

        {

        TPoint baseLine;

        TInt height(0);

        TInt ascent(0);

        TRAPD(ret,iOwner->FepMan()->GetScreenCoordinatesL(baseLine,height,ascent));

        if (ret == KErrNone)

            {

            uiContainer->SetContainerPosition(baseLine, height);    

            }

        }

    ShowInfoOnEEPPane();

    if ( !CheckAllKeystroke() )

        {

        SetWarningColor();

        }

    ShowInfoOnCandidatePane();

    UpdateIndicator();

    TRAP_IGNORE( ChangeCbaL() );

    }

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

// TAknFepInputStateStrokePhraseBase::HandleHorizontalNavigation

// Handle horizontal navigation.

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

//

TBool TAknFepInputStateStrokePhraseBase::CheckFirstGroupStroke()

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    CDesCArrayFlat* keystroke = uiContainer->

        PinyinPopupWindow()->KeystrokeArrayForStroke();

    TInt stringBeforeLength = 0;

    TInt stringAfterLength = 0;

    TInt keyCode = 0;

    TInt pos = 0;

    if ( 0 == keystroke->Count() )

        {

        return EFalse;

        }

    ClearPtiEngineKeystroke();

    TBuf<1> delimiter;

    delimiter.Append( KDelimiter );

    if ( 0 == keystroke->Find( delimiter, pos ) )

        {

        if ( 0 == pos )

            {

            return EFalse;

            }

        }

    else

        {

        pos = keystroke->Count();

        }

    for ( TInt i = 0; i < pos; ++i )

        {

        GetKeystrokeCode( keyCode, keystroke->MdcaPoint( i ) );

        stringBeforeLength = 

            ptiengine->GetPhoneticSpelling(KEnginePhoneticIndex).Length();

        stringAfterLength = 

            ptiengine->AppendKeyPress((TPtiKey)keyCode).Length();

        //the keystroke is invalid.

        if ( stringBeforeLength == stringAfterLength )

            {

            ClearPtiEngineKeystroke();

            return EFalse;

            }

        } 

    return ETrue;

    }

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

// TAknFepInputStateStrokePhraseBase::HandleKeyBackspaceL

// Handle KeyBackspace event.

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

//

void TAknFepInputStateStrokePhraseBase::HandleKeyBackspaceL(

                                                    TKeyPressLength aLength )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    CDesCArrayFlat* keystroke = popup->KeystrokeArrayForStroke();

    TInt phraseCount = popup->ChooseChineseCharacterArrayForStroke()->Count();

    TBool firstGroup = CheckFirstGroupStroke();

    if ( ( 0 == index ) && ( phraseCount != 0 ) )

        {

        RevertPhraseToKeystrokeL();

        }

    else if ( ( 0 == index ) && ( keystroke->Count() > 0 ) )

        {

        iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

        return;

        }

    else

        {

        if ( !DeleteKeystroke() )

            {

            iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

            return;

            }

        }

    if ( popup->ChooseChineseCharacterArrayForStroke()->Count() == 0 )

        {

        iOwner->FepMan()->PhraseCreation( EFalse );

        }

    //if the keystroke is null and phrase is null then close input window.

    if ( ( 0 == phraseCount ) && ( keystroke->Count() == 0 ) )

        {

        iOwner->FepMan()->TryCloseUiL(); //no more keys, close the UI.

        if ( aLength == ELongKeyPress )

            {

            iOwner->FepMan()->SetLongClearAfterCloseUI( ETrue );

            }

        return;

        }

    //Auto change from EStrokeSequenceEdit state to EEntry state. 

    if ( EStrokeSequenceEdit == iState )

        {

        if ( ( KAutoChangeState == popup->GetState() ) && 

              ( !firstGroup ) && CheckFirstGroupStroke() )

            {

            popup->SetChangeState( EFalse );

            iOwner->ChangeState( EEntry );

            return;

            }

        }

    //Auto change from EEntry state to EStrokeSequenceEdit state.

    if ( EEntry == iState )

        {

        if ( ( firstGroup ) && ( !CheckFirstGroupStroke() ) )

            {

            popup->SetChangeState( EFalse );

            popup->SetState( KAutoChangeState );

            iOwner->ChangeState( EStrokeSequenceEdit );

            return;

            }

        }

    RefreshUI();

    }

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

// TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKEntryL

// Entry handle CBA1 or OK key press event.

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

//

void TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKEntry(

                                                    TKeyPressLength aLength )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    TBool state = ETrue;

    if ( popup->IsChangeStatet() && aLength == ELongKeyPress )

        {

        state = EFalse;

        }

    else

        {

        popup->SetChangeState( EFalse );

        }

    if ( state )

        {

        popup->SetChangeState( ETrue );

        iOwner->ChangeState( ECandidate );        

        }    

    }

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

// TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKEditL

// Edit state handle CBA1 or OK key press event.

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

//

void TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKEditL()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    CDesCArrayFlat* phrase = popup->ChooseChineseCharacterArrayForStroke();

    CDesCArrayFlat* keystrokeArray = popup->KeystrokeArrayForStroke();

    TBuf<KMaxPhraseCreationCount> phraseCreated;

    if ( (phrase->Count() >= 2 ) && ( 0 == keystrokeArray->Count() ) )

        {

        //commit the chinese character.

        for (TInt i = 0; i < phrase->Count(); ++i )

            {

            phraseCreated.Append( phrase->MdcaPoint( i ) );

            }

        AddPhraseToDB( phraseCreated );

        iOwner->FepMan()->NewTextL( phraseCreated );

        iOwner->FepMan()->CommitInlineEditL();

        iOwner->FepMan()->TryCloseUiL(); //no more keys, close the UI.

        }

    else if ( CheckFirstGroupStroke() )

        {

        popup->SetState( KManualChangeState );

        popup->SetChangeState( ETrue );

        iOwner->ChangeState( EEntry );

        }

    else

        {

        iOwner->FepMan()->PlaySound( EAvkonSIDErrorTone );

        }

    }

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

// TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKL

// Handle CBA1 or OK key press event.

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

//

void TAknFepInputStateStrokePhraseBase::HandleKeyCBA1OrKeyOKL(

                                                    TKeyPressLength aLength )

    {

    if ( EStrokeSequenceEdit == iState )

        {

        HandleKeyCBA1OrKeyOKEditL();

        }

    else if ( EEntry == iState )

        {

        HandleKeyCBA1OrKeyOKEntry( aLength );

        }

    else

        {

        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

        }

    }

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

// TAknFepInputStateStrokePhraseBase::HandleDefaultKeyL

// Handle default key press event.

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

//

void TAknFepInputStateStrokePhraseBase::HandleDefaultKeyL( TInt aKey )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    TBool firstGroup = CheckFirstGroupStroke();

    if ( !AddKeystrokeL( aKey ) )

        {

        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

        return;

        }

    //Auto change from EStrokeSequenceEdit state to EEntry state. 

    if ( EStrokeSequenceEdit == iState )

        {

        if ( ( KAutoChangeState == popup->GetState() ) && 

              ( !firstGroup ) && CheckFirstGroupStroke() )

            {

            popup->SetChangeState( ETrue );

            iOwner->ChangeState( EEntry );

            return;

            }

        }

    //Auto change from EEntry state to EStrokeSequenceEdit state.

    if ( EEntry == iState )

        {

        if ( ( firstGroup ) && ( !CheckFirstGroupStroke() ) )

            {

            popup->SetState( KAutoChangeState );

            popup->SetChangeState( ETrue );

            iOwner->ChangeState( EStrokeSequenceEdit );

            return;

            }

        }

    RefreshUI();

    }

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

// TAknFepInputStateStrokePhraseBase::ShowInfoOnEEP

// Show the showinfo on the EEP ctrl.

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

//

void TAknFepInputStateStrokePhraseBase::ShowInfoOnEEPPane()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystroke = popup->KeystrokeArrayForStroke();

    CDesCArrayFlat* phrase = popup->ChooseChineseCharacterArrayForStroke();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    TBuf<KMaxKeystrokeCount> showInfo;

    for (TInt i = 0; i < phrase->Count(); ++i )

        {

        showInfo.Append( phrase->MdcaPoint( i ) );

        }

    for (TInt ii = 0; ii < keystroke->Count(); ++ii )

        {

        showInfo.Append( keystroke->MdcaPoint( ii ) );

        }

    editPane->SetText( showInfo, phrase->Count() + index );

    if ( EStrokeSequenceEdit == iState )

        {

        editPane->ActiveCursor();

        }