/*

* 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 <e32cmn.h>

#include <PtiEngine.h>

#include <PtiDefs.h>

#include <avkon.rsg>

#include <AknFep.rsg>

#include <PtiUserDicEntry.h>

#include <aknnotewrappers.h> //CAknWarningNote 

// User includes

#include "AknFepUIManagerStateInterface.h"

#include "AknFepUICtrlInputPane.h"

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

#include "AknFepUICtrlCandidatePane.h"

#include "AknFepManager.h"

#include "aknfepuiinputminiqwertystrokephrasebase.h"

// CONSTANTS

const TInt KMaxPhraseCount = 50;

const TInt KMaxPhraseCreationCount = 7;

const TInt KMaxKeystrokeCount = 31;

const TInt16 KStrokeDelimiter = 0x2022;

const TInt16  KStrokeUnicode = 0x2461;

const TInt16 KKey1 = 0x31;

const TInt16 KKey6 = 0x36;

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

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

// TAknFepInputStateStrokePhraseCreationBase::TAknFepInputStateStrokePhraseCreationBase

// C++ default constructor

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

//

TAknFepInputMiniQwertyStrokePhraseBase::TAknFepInputMiniQwertyStrokePhraseBase(

    MAknFepUIManagerStateInterface* aOwner,

    MAknFepUICtrlContainerChinese* aUIContainer)

    :TAknFepInputStateCandidateQwertyBaseChinesePhrase(aOwner, aUIContainer)

    {

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

    iOwner->PtiEngine()->SetCase(EPtiCaseLower);

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

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlCandidatePane* candidatePane = uiContainer->CandidatePane();

    TBool multiplePages = !(candidatePane->IsLastPage() &&

                            candidatePane->IsFirstPage());

    uiContainer->ShowVerticalScrollArrows(multiplePages);

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleKeyL

// Handle system key press event.

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

//

TBool TAknFepInputMiniQwertyStrokePhraseBase::HandleKeyL( 

                                        TInt aKey, 

                                        TKeyPressLength aLength )

    {

    TBool ret = ETrue;

    const TPtiKeyboardType keyboardType = iOwner->PtiEngine()->KeyboardType();

    switch( aKey )

        {

        case EKeyLeftShift:

        case EKeyLeftCtrl:

        case EKeyRightCtrl:

        case EStdKeyLeftFunc:    

            {

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

            ret = EFalse;

            break;

            }

        case EStdKeyDevice1:// CBA2

            {

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

            break;

            }

        case EStdKeyUpArrow:

        case EStdKeyDownArrow:    

        case EKeyRightFunc:

        case EStdKeyEnter:     

            {

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

            break;

            }

        case EStdKeyBackspace:

            {

            HandleKeyBackspaceL( aLength );

            break;

            }

        case EStdKeyDevice0:// CBA1

        case EStdKeyDevice3:// CBASelect

            {

            HandleCommitL( aLength );

            break;

            }

        case EStdKeyLeftArrow:

            {

            if ( !MoveCursorLeft() )

                {

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

                }

            break;

            }    

        case EStdKeyRightArrow:

            {            

            if ( !MoveCursorRight() )

                {

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

                }            

            break;

            }

        default:

            {

            ret = HandleDefaultL( aKey, aLength );

            break;

            }

        }

    return ret;

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::RefreshUI

// Update input window.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::RefreshUI()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    // get cursor position

    if ( ( uiContainer->EditPaneWindow()->KeystrokeArray()->Count() == 0 ) && 

        ( uiContainer->EditPaneWindow()->PhraseArray()->Count() == 0 ) )

        {

        TPoint baseLine;

        TInt height(0);

        TInt ascent(0);

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

        if (ret == KErrNone)

            {

            uiContainer->SetContainerPosition(baseLine, height);    

            }

        }

    if ( ( uiContainer->EditPaneWindow()->KeystrokeArray()->Count() > 0 ) ||

        ( uiContainer->EditPaneWindow()->PhraseArray()->Count() > 0 ) )

        {

        ShowInfoOnEEPPane();

        SetWarningColor();

        ShowInfoOnCandidatePane();

        UpdateIndicator();

        TRAP_IGNORE( ChangeCbaL() );

        }

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::CheckFirstGroupStroke

// check the first group stroke of keystroke.

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

//

TBool TAknFepInputMiniQwertyStrokePhraseBase::CheckFirstGroupStroke()

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();

    RArray<TInt>* keycodeArray = editPane->KeycodeArray();

    TInt stringBeforeLength = 0;

    TInt stringAfterLength = 0;

    TInt keyCode = 0;

    TInt pos = 0;

    TBuf<1> delimiter;

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

        {

        return EFalse;

        }

    delimiter.Append( KStrokeDelimiter );

    //the keystroke is not delimiter the all keystroke is first group keystroke.

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

        {

        pos = keystroke->Count();

        }

    //first keystroke is delimiter then first group keystroke is invalid.

    if ( 0 == pos )

        {

        return EFalse;

        }

    ClearPtiEngineKeystroke();

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

        {

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

        keyCode = (*keycodeArray)[i];

        stringBeforeLength = 

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

        stringAfterLength = 

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

        //the keystroke is invalid.

        if ( stringBeforeLength == stringAfterLength )

            {

            return EFalse;

            }

        } 

    return ETrue;

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleCommitL

// Handle CBA1 or select event.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::HandleCommitL( 

                                                     TKeyPressLength aLength )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    TInt keyCount = editPane->KeystrokeArray()->Count();

    CDesCArrayFlat* phrase = editPane->PhraseArray();

    TInt cdtCount = uiContainer->CandidatePane()->CandidateArray()->Count(); 

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    if ( !CheckKeyNeedRepeat( aLength ) )

        {

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

        return;

        }

    if ( EMiniQwertyEdit == iState )

        {

        if ( cdtCount > 0 )

            {

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

            iOwner->ChangeState( ECandidate );            

            return;

            }

        if ( keyCount > 0 )

            {

            fepMan->PlaySound( EAvkonSIDErrorTone );

            return;

            }

        }

    if ( phrase->Count( ) <= 1 )

        {

        fepMan->PlaySound( EAvkonSIDErrorTone );

        return;

        }

    TBuf<KMaxPhraseCreationCount> phraseCreated;

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

        {

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

        }

    fepMan->NewTextL( phraseCreated );

    fepMan->CommitInlineEditL( );

    AddPhraseToDB( phraseCreated );

    fepMan->TryCloseUiL( );

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleAutoChangeState

// Auto change state.

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

//

TBool TAknFepInputMiniQwertyStrokePhraseBase::HandleAutoChangeState()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    TBool FirstStrokeValid = CheckFirstGroupStroke();

    //Auto change from EMiniQwertyEdit state to EEntry state. 

    if ( EMiniQwertyEdit == iState )

        {

        if ( FirstStrokeValid )

            {

            if ( EAutoChangeStateFromInput == editPane->GetAutoChangeStateFlag() )

                {

                editPane->SetChangeState( EFalse );

                iOwner->ChangeState( EEntry );

                return ETrue;

                }

            else if ( EAutoChangeStateFromCandidate == editPane->GetAutoChangeStateFlag() )

                {

                editPane->SetChangeState( ETrue );

                iOwner->ChangeState( ECandidate );

                return ETrue;

                }

            }

        }

    //Auto change from EEntry state to EMiniQwertyEdit state.

    if ( EEntry == iState )

        {

        if ( ( 0 <= index ) && ( !FirstStrokeValid ) )

            {

            editPane->SetChangeState( EFalse );

            editPane->SetAutoChangeStateFlag( EAutoChangeStateFromInput );

            iOwner->ChangeState( EMiniQwertyEdit );

            return ETrue;

            }

        }

    return EFalse;

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleKeyBackspaceL

// Handle KeyBackspace event.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::HandleKeyBackspaceL(

                                                    TKeyPressLength aLength )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();

    TInt phraseCount = editPane->PhraseArray()->Count();

    if ( !CheckKeyNeedRepeat( aLength ) )

        {

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

        return;

        }

    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 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;

        }

    if ( !HandleAutoChangeState() )

        {

        RefreshUI();

        }

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleDefaultL

// Handle default event.

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

//

TBool TAknFepInputMiniQwertyStrokePhraseBase::HandleDefaultL( 

                                                     TInt aKey,

                                                     TKeyPressLength aLength )

    {

    TBool ret = ETrue;

    if( CAknFepFnKeyManager::EFnKeyNext == iOwner->FepMan()->FnKeyState() ||

             CAknFepFnKeyManager::EFnKeyLock == iOwner->FepMan()->FnKeyState() ||

             ( CAknFepFnKeyManager::EFnKeyDown == iOwner->FepMan()->FnKeyState() && iState != ECandidate ))

        {

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

        }

    else if (iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagShiftKeyDepressed) ||

             iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed))

        {

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

        ret = EFalse;

        }

    else if ( ( EShortKeyPress == aLength ) && 

        ( iOwner->IsValidChineseInputKeyQwerty( aKey ) ) )

        {

        if ( iState == ECandidate )

            {

            HandleKeyFromCandidateL( aKey, aLength );

            }

        else

            {

            HandleDefaultKeyL( aKey );

            }

        }

    else

        {

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

        }

    return ret;

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::HandleDefaultKeyL

// Handle default key press event.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::HandleDefaultKeyL( TInt aKey )

    {

    if ( !AddKeystrokeL( aKey ) )

        {

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

        return;

        }

    if ( !HandleAutoChangeState() )

        {

        RefreshUI();

        }

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::ShowInfoOnEEP

// Show the showinfo on the EEP ctrl.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::ShowInfoOnEEPPane()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();

    CDesCArrayFlat* phrase = editPane->PhraseArray();

    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, index + phrase->Count() );

    switch ( iState )

        {

        case ECandidate:

            editPane->DisableCursor();

            break;

        case EEntry:

            editPane->EnableCursor();

            editPane->DeactiveCursor();

            break;

        case EMiniQwertyEdit:

            editPane->EnableCursor();

            editPane->ActiveCursor();

            break;

        default:

            break;

        }

    }

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

// TAknFepInputMiniQwertyStrokePhraseBase::ShowInfoOnEEP

// Show the showinfo on the EEP ctrl.

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

//

void TAknFepInputMiniQwertyStrokePhraseBase::ShowInfoOnCandidatePane()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    CDesCArrayFlat* phrase = uiContainer->CandidatePane()->CandidateArray();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    if ( KMaxPhraseCreationCount == editPane->PhraseArray()->Count() )

        {

        phrase->Reset();

        TRAP_IGNORE( phrase->AppendL( KMaxPhraseNote ) );

        uiContainer->CandidatePane()->SplitPhraseCandidatesIntoPages();

        uiContainer->CandidatePane()->SetCandidateBuffer();

        uiContainer->Enable( ETrue );

        uiContainer->ShowHorizontalScrollArrows( EFalse );

        uiContainer->ShowVerticalScrollArrows( EFalse );

        }

    TRAP_IGNORE( GetCandidateL() );

    if ( phrase->Count() > 0 )

        {

        // layout candidate and fill candidate buffer for first display page

        uiContainer->CandidatePane()->SplitPhraseCandidatesIntoPages();

        uiContainer->CandidatePane()->SetCandidateBuffer();

        uiContainer->Enable( ETrue );

        TBool multiplePages = !(uiContainer->CandidatePane()->IsLastPage() &&