/*

* Copyright (c) 2007 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  TAknFepInputStateEntryMiniQwertyZhuyinPhrase,

 *       TAknFepInputStateEditingMiniQwertyZhuyinPhrase,

 *       TAknFepUiInputStateCandidateMiniQwertyZhuyinPhrase methods.

 *

*/

// System includes

#include <PtiEngine.h>  

#include <PtiUserDicEntry.h>

#include <aknnotewrappers.h> //CAknWarningNote

// User includes

#include "AknFepUiCtrlContainerChinese.h"

#include "AknFepUICtrlCandidatePane.h"

#include "AknFepUICtrlInputPane.h"

#include "aknfepuictrleditpane.h"           //phrase creation

#include "AknFepUICtrlPinyinPopup.h"        //Pinyin phrase

#include "AknFepUIManagerStateInterface.h"  

#include "AknFepManager.h" 

#include "aknfepuiinputstateminiqwertyzhuyinphrase.h"

#include "aknfepinputstateminiqwertyzhuyinkeymap.h"

const TInt KMaxKeystrokeCount = 31;

const TInt KMaxKeystrokeSize = 130;

const TInt KMaxPhraseLength = 7;

const TInt KMinCandidateCount = 1;

const TInt KKeystrokeMaxLength = 4;

//const TInt KTonemarkCount = 5;

const TUint16 KToneMark1 = 0x0020;

const TUint16 KToneMark2 = 0x02CA;

const TUint16 KToneMark3 = 0x02c7;

const TUint16 KToneMark4 = 0x02CB;

const TUint16 KToneMark5 = 0x02D9;

_LIT(KLeftBracket, "(");

_LIT(KRightBracket, ")");

_LIT(KReplace, "");

_LIT( KDelimiter, "'");

struct TToneZhuYinMap

    {

    TUint16 iValue;

    TInt iInputTone;

    };

const TToneZhuYinMap ZhuyinToneMap[] =

    {

        {KToneMark1, 1},

        {KToneMark2, 2},

        {KToneMark3, 3},

        {KToneMark4, 4},

        {KToneMark5, 5}

    };

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::TAknFepInputStateEditingMiniQwertyZhuyinPhrase

// C++ default constructor

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

//

TAknFepInputStateEditingMiniQwertyZhuyinPhrase::TAknFepInputStateEditingMiniQwertyZhuyinPhrase(

    MAknFepUIManagerStateInterface* aOwner,

    MAknFepUICtrlContainerChinese* aUIContainer ) :

    TAknFepInputMiniQwertyZhuyinPhraseBase( aOwner, aUIContainer)

    {

    iState = EMiniQwertyEdit;

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    uiContainer->FocusCandidatePane( EFalse );

    uiContainer->CandidatePane()->ShowCandidateOrdinals( EFalse );

    uiContainer->SetLayout( MAknFepUICtrlContainerChinese::ELayoutPhraseCreation );

    uiContainer->CandidatePane()->SelectFirstPhrase();

    uiContainer->ShowVerticalScrollArrows( ETrue );

    uiContainer->ShowHorizontalScrollArrows( EFalse );

    uiContainer->InputPane()->SetOverrideFontId( 0 );

    // in the case that we are coming back to the input pane from the candidate pane, 

    // we need to ensure that the current selection is selected correctly

    ImplicityShowInfo( ETrue );

    // so that it could handle EKeyCBA1

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

    RefreshEditPane();

    uiContainer->PinyinPopupWindow()->SetNoneHighlighted();

    TRAP_IGNORE( ChangeCbaL() );

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::HandleKeyL

// Handle system key press event.

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

// 

TBool TAknFepInputStateEditingMiniQwertyZhuyinPhrase::HandleKeyL( TInt aKey,

    TKeyPressLength aLength )

    {

    TBool ret = ETrue;

    TBool state = ETrue;

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlCandidatePane* candidatePane = UIContainer()->CandidatePane();

    MAknFepUICtrlEditPane* editPane = UIContainer()->EditPaneWindow();

    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();

    CDesCArrayFlat* phraseArray = editPane->PhraseArray();

    if ( iOwner->FepMan()->GetComposChrFlag() && aKey == EStdKeyLeftFunc )

        {

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

        return ret;

        }

    switch ( aKey )

        {

        case EStdKeyLeftShift:

        case EStdKeyRightShift:

        case EStdKeyLeftCtrl:

        case EStdKeyRightCtrl:

        case EStdKeyRightFunc://fn 

        case EStdKeyLeftFunc: //chr key

        case EStdKeyUpArrow:

        case EKeyRightFunc:

        case EKeyLeftFunc:

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

            break;

            //if the canidate is empty ,inactive;else candiniate selecting state

        case EStdKeyDownArrow:

            {

            if ( 0 != candidatePane->VisibleCandidateCount() && phraseArray->Count() < 7 )

                {

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

                iOwner->ChangeState( EZhuyinSpelling );

                }

            }

            break;

        case EStdKeyRightArrow:

            MoveCursorRight();

            break;

        case EStdKeyLeftArrow:

            MoveCursorLeft();

            break;

        case EStdKeyDevice1: //"cancle" key

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

            break;

        case EStdKeyEnter:

            CommitContentL( EFalse );

            break;

        case EStdKeyDevice0:

        case EStdKeyDevice3:

            if ( editPane->IsChangeState() && aLength == ELongKeyPress )

                {

                state = EFalse;

                }

            else

                {

                editPane->SetChangeState( EFalse );

                }

            if ( state )

                {

                HandleCommitL();

                }

            break;

        case EStdKeyBackspace:

            {

            if ( editPane->IsChangeState() && aLength == ELongKeyPress )

                {

                state = EFalse;

                }

            else

                {

                editPane->SetChangeState( EFalse );

                }

            if ( state )

                {

                HandleKeyBackspaceL( aLength );

                }

            }

            break;

        default:

            {

            if ( aLength == EShortKeyPress && keystrokeArray->Count() < KMaxKeystrokeCount && 

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

                phraseArray->Count() < KMaxPhraseLength &&

                ( iOwner->IsValidChineseInputKeyQwerty( aKey ) || aKey == EStdKeySpace ) )

                {

                AddKeystrokeL( aKey );

                RefreshUI();

                ShowEEPInfo();

                ChangeCbaL();

                }

            else

                {

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

                }

            }

            break;

        }

    return ret;

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::AddKeystrokeL

// Add key stroke.

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

// 

TBool TAknFepInputStateEditingMiniQwertyZhuyinPhrase::AddKeystrokeL( TInt aKey )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();

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

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

    TInt showKeystrokeCount = editPane->ShowKeystrokeArray()->Count();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    if ( phraseCount + showKeystrokeCount >= KMaxKeystrokeCount - 1 )

        {

        return EFalse;

        }

    TBuf<KKeystrokeMaxLength> keystroke;

    TAknFepInputStateMiniQwertyZhuyinKeyMap::GetKeyStroke(

            iOwner->PtiEngine(), aKey, keystroke );

    if ( index >= keystrokeArray->Count() )

        {

        keycodeArray->Append( aKey );

        keystrokeArray->AppendL( keystroke );

        editPane->SetCursorIndexOfKeystroke( keystrokeArray->Count() );

        }

    else

        {

        keycodeArray->Insert( aKey, index );

        keystrokeArray->InsertL( index, keystroke );

        editPane->SetCursorIndexOfKeystroke( index + 1 );

        }

    editPane->SetNeedClearDeliberateSelection( ETrue );

    return ETrue;

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::RevertPhraseToKeystrokeL

// Revert the phrase to keystroke.

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

//

void TAknFepInputStateEditingMiniQwertyZhuyinPhrase::RevertPhraseToKeystrokeL()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();

    CDesCArrayFlat* phrase = editPane->PhraseArray();

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

    RArray<TInt>* phraseKeycode = editPane->PhraseKeycodeArray();

    CDesCArrayFlat* phraseStroke = editPane->PhraseShowKeyStrokeArray();

    TBuf<KMaxKeystrokeCount> buf;

    if ( (phrase->Count() == 0 ) || (phraseStroke->Count() == 0 ) )

        {

        return;

        }

    buf.Append( phraseStroke->MdcaPoint( phraseStroke->Count() - 1 ) );

    TInt insertIndex = 0;

    while ( buf.Length() != 0 )

        {

        TBuf<KKeystrokeMaxLength> strokeBuf;

        TInt index = buf.Find( KRightBracket );

        if ( index != KErrNotFound )

            {

            strokeBuf.Copy( buf.Left( index + 1 ) );

            keystrokeArray->InsertL( insertIndex, strokeBuf );

            buf.Replace( 0, index + 1, KNullDesC );

            }

        else

            {

            keystrokeArray->InsertL( insertIndex, buf );

            insertIndex = insertIndex + 1;

            break;

            }

        insertIndex = insertIndex + 1;

        }

    phrase->Delete( phrase->Count() - 1 );

    phraseStroke->Delete( phraseStroke->Count() - 1 );

    if ( insertIndex > phraseKeycode->Count() )

        {

        insertIndex = keycodeArray->Count();

        }

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

        {

        keycodeArray->Insert( (*phraseKeycode)[phraseKeycode->Count() - 1 ],0 );

        phraseKeycode->Remove( phraseKeycode->Count() - 1 );

        }

    TInt keystrokeCount = keystrokeArray->Count();

    TInt lenth = phrase->Count() + keystrokeCount;

    TInt deleteCount = lenth - KMaxKeystrokeCount;

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

        {

        keycodeArray->Remove( keycodeArray->Count() - 1 );

        keystrokeArray->Delete( keystrokeArray->Count() - 1 );

        }

    editPane->SetCursorIndexOfKeystroke( insertIndex );

    keystrokeArray->Compress();

    phrase->Compress();

    phraseStroke->Compress();

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::AddPhraseToDB

// Add phrase to DB.

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

//

void TAknFepInputStateEditingMiniQwertyZhuyinPhrase::AddPhraseToDB(

    const TDesC& aPhraseAdd )

    {

    TPtiUserDictionaryEntry addUdbEntry(aPhraseAdd);

    //Add the phrase to the DB by PTI Engine

    iOwner->PtiEngine()->AddUserDictionaryEntry( addUdbEntry );

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::MoveCursorLeft

// Move the cursor to Left.

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

//

TBool TAknFepInputStateEditingMiniQwertyZhuyinPhrase::MoveCursorLeft()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keyStrokeArray = editPane->KeystrokeArray();

    TInt keystrokeCount = keyStrokeArray->Count();

    TInt index = editPane->GetCursorIndexOfKeystroke();

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

    if ( EMiniQwertyEdit != iState )

        {

        return EFalse;

        }

    if ( 0 == keystrokeCount )

        {

        return EFalse;

        }

    if ( 0 == index )

        {

        editPane->SetCursorIndexOfKeystroke( keystrokeCount );

        ShowEEPInfo();

        }

    else if ( phraseCount > 0 && 1 == index )

        {

        editPane->SetCursorIndexOfKeystroke( 0 );

        ShowEEPInfo();

        }

    else

        {

        TInt stride = keyStrokeArray->MdcaPoint( index - 1 ).Length();

        editPane->MoveCursorLeft( stride );

        editPane->SetCursorIndexOfKeystroke( index - 1 );

        }

    return ETrue;

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::MoveCursorRight

// Move the cursor to Right.

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

//

TBool TAknFepInputStateEditingMiniQwertyZhuyinPhrase::MoveCursorRight()

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();

    TInt keystrokeCount = keystroke->Count();

    TInt index = editPane->GetCursorIndexOfKeystroke();

    if ( EMiniQwertyEdit != iState )

        {

        return EFalse;

        }

    if ( 0 == keystrokeCount )

        {

        return EFalse;

        }

    if ( index >= keystrokeCount )

        {

        editPane->SetCursorIndexOfKeystroke( 0 );

        ShowEEPInfo();

        }

    else

        {

        TInt stride = editPane->KeystrokeArray()->MdcaPoint( index ).Length();

        editPane->MoveCursorRight( stride );

        editPane->SetCursorIndexOfKeystroke( index + 1 );

        }

    return ETrue;

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::HandleKeyBackspace

// Handle Key Backspace

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

//

void TAknFepInputStateEditingMiniQwertyZhuyinPhrase::HandleKeyBackspaceL( 

                                                     TKeyPressLength aLength )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();

    CDesCArrayFlat* keyStrokeArray = editPane->KeystrokeArray();

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

    TInt keystrokeCount = keyStrokeArray->Count();

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

    TInt cursorOfkeystrokeIndex = editPane->GetCursorIndexOfKeystroke();

    if ( 1 == cursorOfkeystrokeIndex )

        {

        editPane->Reset();

        }

    if ( cursorOfkeystrokeIndex > 0 && 

        ( keystrokeCount > 1 || phraseCount > 0 ) )

        {

        keycodeArray->Remove( cursorOfkeystrokeIndex - 1 );

        keyStrokeArray->Delete( cursorOfkeystrokeIndex - 1 );

        editPane->SetCursorIndexOfKeystroke( cursorOfkeystrokeIndex - 1 );

        }

    else if ( phraseCount > 0 && 0 == cursorOfkeystrokeIndex )

        {

        RevertPhraseToKeystrokeL();

        }

    else if ( 1 == cursorOfkeystrokeIndex )

        {

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

        if ( aLength == ELongKeyPress )

            {

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

            }

        return;

        }

    else

        {

        return;

        }

    editPane->SetNeedClearDeliberateSelection( ETrue );

    RefreshUI();

    ShowEEPInfo();

    ChangeCbaL();

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::CommitContentL

// Commit content

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

//

void TAknFepInputStateEditingMiniQwertyZhuyinPhrase::CommitContentL(

    TBool aAddUDB )

    {

    TBuf<KMaxKeystrokeSize> currentText;

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    MAknFepUICtrlEditPane* editpane = UIContainer()->EditPaneWindow();

    CDesCArrayFlat* phraseArray = editpane->PhraseArray();

    CDesCArrayFlat* keystrokeArray = editpane->KeystrokeArray();

    TInt phraseCount = phraseArray->Count();

    TInt keyStrokeCount = keystrokeArray->Count();

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

        {

        currentText.Append( phraseArray->MdcaPoint( i ) );

        }

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

        {

        currentText.Append( keystrokeArray->MdcaPoint( i ) );

        }

    if ( currentText.Length() )

        {

        while (currentText.Find( KLeftBracket ) >= 0 )

            {

            currentText.Replace( currentText.Find( KLeftBracket ), 1,

                KReplace );

            }

        while (currentText.Find( KRightBracket ) > 0 )

            {

            currentText.Replace( currentText.Find( KRightBracket ), 1,

                KReplace );

            }

        fepMan->NewTextL( currentText );

        fepMan->CommitInlineEditL();

        }

    UIContainer()->EditPaneWindow()->ResetAllArray();

    UIContainer()->EditPaneWindow()->SetPhraseCreationFlag( EFalse );

    if ( fepMan->IsFlagSet( CAknFepManager::EFlagEditorFull ) )

        {

        fepMan->ClearFlag( CAknFepManager::EFlagEditorFull );

        }

    if ( aAddUDB )

        {

        AddPhraseToDB( currentText );

        }

    fepMan->TryCloseUiL();

    }

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

// TAknFepInputStateEditingMiniQwertyZhuyinPhrase::HandleCommitL