/*
* 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 "AknFepUICtrlPinyinPopup.h"        //Pinyin phrase
#include "aknfepuictrleditpane.h"           //pinyin phrase creation
#include "AknFepUICtrlCandidatePane.h"
#include "AknFepManager.h"
#include "aknfepuiinputminiqwertypinyinphrasebase.h"

// Constant definition
const TInt KMaxPhraseCount = 50;
const TInt KMaxPhraseCreationCount = 7;
const TInt KMaxSpellLength = 7;//max pinyin length for one chinese Zi
const TInt KMaxKeystrokeCount = 31;
const TInt KInvalidToneMark = -1;
const TUint16 KAutoDLT = 0x002E;
const TUint16 KManualDLT = 0x0027;
const TUint16 KPYa = 0x0061;
const TUint16 KPYb = 0x0062;
const TUint16 KPYc = 0x0063;
const TUint16 KPYd = 0x0064;
const TUint16 KPYe = 0x0065;
const TUint16 KPYf = 0x0066;
const TUint16 KPYg = 0x0067;
const TUint16 KPYh = 0x0068;
const TUint16 KPYi = 0x0069;
const TUint16 KPYj = 0x006A;
const TUint16 KPYk = 0x006B;
const TUint16 KPYl = 0x006C;
const TUint16 KPYm = 0x006D;
const TUint16 KPYn = 0x006E;
const TUint16 KPYo = 0x006F;
const TUint16 KPYp = 0x0070;
const TUint16 KPYq = 0x0071;
const TUint16 KPYr = 0x0072;
const TUint16 KPYs = 0x0073;
const TUint16 KPYt = 0x0074;
const TUint16 KPYu = 0x0075;
const TUint16 KPYv = 0x0076;
const TUint16 KPYw = 0x0077;
const TUint16 KPYx = 0x0078;
const TUint16 KPYy = 0x0079;
const TUint16 KPYz = 0x007A;

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

const TMiniQwertyKeyMap StrokeMap[] =
    {
    {KPYa, EPtiKeyQwertyA},
    {KPYb, EPtiKeyQwertyB},
    {KPYc, EPtiKeyQwertyC},
    {KPYd, EPtiKeyQwertyD},
    {KPYe, EPtiKeyQwertyE},
    {KPYf, EPtiKeyQwertyF},
    {KPYg, EPtiKeyQwertyG},
    {KPYh, EPtiKeyQwertyH},
    {KPYi, EPtiKeyQwertyI},
    {KPYj, EPtiKeyQwertyJ},
    {KPYk, EPtiKeyQwertyK},
    {KPYl, EPtiKeyQwertyL},
    {KPYm, EPtiKeyQwertyM},
    {KPYn, EPtiKeyQwertyN},
    {KPYo, EPtiKeyQwertyO},
    {KPYp, EPtiKeyQwertyP},
    {KPYq, EPtiKeyQwertyQ},
    {KPYr, EPtiKeyQwertyR},
    {KPYs, EPtiKeyQwertyS},
    {KPYt, EPtiKeyQwertyT},
    {KPYu, EPtiKeyQwertyU},
    {KPYv, EPtiKeyQwertyV},
    {KPYw, EPtiKeyQwertyW},
    {KPYx, EPtiKeyQwertyX},
    {KPYy, EPtiKeyQwertyY},
    {KPYz, EPtiKeyQwertyZ},
    {KManualDLT, EPtiKeyQwertySpace}
    };

const TMiniQwertyToneMap PinyinToneMap[] =
    {
    {0x02C9, 1},
    {0x02CA, 2},
    {0x02C7, 3},
    {0x02CB, 4},
    {0x02D9, 5}
    };

// ---------------------------------------------------------------------------
// TAknFepInputStateStrokePhraseCreationBase::TAknFepInputStateStrokePhraseCreationBase
// C++ default constructor
// ---------------------------------------------------------------------------
//
TAknFepInputMiniQwertyPinyinPhraseBase::TAknFepInputMiniQwertyPinyinPhraseBase(
    MAknFepUIManagerStateInterface* aOwner,
    MAknFepUICtrlContainerChinese* aUIContainer) :
    TAknFepInputStateCandidateQwertyBaseChinesePhrase(aOwner, aUIContainer)
    {
    if (iOwner->PtiEngine()->InputMode() != EPtiEnginePinyinPhraseQwerty)
        {
        iOwner->PtiEngine()->SetInputMode(EPtiEnginePinyinPhraseQwerty);
        }
    iOwner->PtiEngine()->SetCandidatePageLength(KMaxPhraseCount);
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    TBool multiplePages = !(uiContainer->CandidatePane()->IsLastPage() && uiContainer->CandidatePane()->IsFirstPage());
    uiContainer->ShowVerticalScrollArrows(multiplePages);
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyL
// Handle system key press event.
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyL(TInt aKey,
    TKeyPressLength aLength)
    {
    //
    switch (aKey)
        {
        case EKeyLeftShift:
        case EKeyLeftCtrl:
        case EKeyRightCtrl:
        case EStdKeyDevice1:// CBA2    
            {
            iOwner->FepMan()->TryCloseUiL();
            break;
            }
        case EKeyRightFunc:
            {
            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
            break;
            }
        case EStdKeyLeftFunc: //tone mark.
            {
            HandlToneMarkL();
            break;
            }
        case EStdKeyBackspace:
            {
            if (CheckKeyNeedRepeat(aLength) )
                {
                HandleKeyBackspaceL(aLength);
                }
            else
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                }
            break;
            }
        case EStdKeyEnter://Enter keypress.
            {
            HandlEnterKeyL();
            break;
            }
        case EStdKeyDevice0:// CBA1
        case EStdKeyDevice3:// CBASelect
            {
            HandleCommitL();
            break;
            }
        case EStdKeyUpArrow:
            {
            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
            break;
            }
        case EStdKeyDownArrow:
            {
            if (EMiniQwertyEdit == iState)
                {
                if (CheckFirstGroupStroke() )
                    {
                    iOwner->ChangeState(EEntry);
                    }
                }
            else
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                }
            break;
            }
        case EStdKeyLeftArrow:
            {
            if (EMiniQwertyEdit == iState)
                {
                UIContainer()->EditPaneWindow()->SetAutoChangeStateFlag( EManualChangeState );
                MoveCursorLeft();
                }
            else
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                }
            break;
            }
        case EStdKeyRightArrow:
            {
            if (EMiniQwertyEdit == iState)
                {
                UIContainer()->EditPaneWindow()->SetAutoChangeStateFlag( EManualChangeState );
                MoveCursorRight();
                }
            else
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                }
            break;
            }
        case EStdKeySpace:
            {
            if (EShortKeyPress == aLength)
                {
                HandlSpaceKeyL();
                break;
                }
            break;
            }
        default:
            {
            if (CAknFepFnKeyManager::EFnKeyNext == iOwner->FepMan()->FnKeyState() || CAknFepFnKeyManager::EFnKeyLock
                    == iOwner->FepMan()->FnKeyState()
                    || ( CAknFepFnKeyManager::EFnKeyDown == iOwner->FepMan()->FnKeyState() && iState != ECandidate ))
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                return ETrue;
                }
            else
                if (iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagShiftKeyDepressed)
                        || iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed))
                    {
                    iOwner->FepMan()->TryCloseUiL();
                    return EFalse;
                    }
                else
                    if ( (EShortKeyPress == aLength )
                            && (iOwner->IsValidChineseInputKeyQwerty(aKey) ))
                        {
                        if (iState == ECandidate)
                            {
                            HandleKeyFromCandidateL(aKey, aLength);
                            }
                        else
                            {
                            HandleDefaultKeyL(aKey);
                            }
                        }
                    else
                        {
                        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                        }
            break;
            }
        }

    return ETrue;
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::RefreshUI
// Update input window.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::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);
            }
        }
    if ( (uiContainer->EditPaneWindow()->KeystrokeArray()->Count() > 0 ) || 
        (uiContainer->EditPaneWindow()->PhraseArray()->Count() > 0 ) )
        {
        ShowInfoOnEEPPane();
        SetWarningColor();
        ShowInfoOnCandidatePane();
        UpdateIndicator();
        TRAP_IGNORE( ChangeCbaL() );
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckFirstGroupStroke
// check the first group stroke of keystroke.
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckFirstGroupStroke()
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    TInt stringBeforeLength = 0;
    TInt stringAfterLength = 0;
    TInt keyCode = 0;
    TInt toneMark = 0;
    if ( 0 == showKeystroke->Count() )
        {
        return EFalse;
        }

    if (KInvalidToneMark != ToneMark(showKeystroke->MdcaPoint( 0) ) )
        {
        return EFalse;
        }

    ClearPtiEngineKeystroke();
    for (TInt i = 0; i < showKeystroke->Count(); ++i)
        {
        if (CheckSpellingDLT(showKeystroke->MdcaPoint(i) ) )
            {
            if ( 0 == i)
                {
                return EFalse;
                }
            else
                {
                return ETrue;
                }
            }
        toneMark = ToneMark(showKeystroke->MdcaPoint(i) );
        if (KInvalidToneMark != toneMark)
            {
            for (TInt j = 0; j < toneMark; ++j)
                {
                ptiengine->IncrementToneMark(ETrue);
                TPtrC ptr0 = getCurrentLeastDLTSpell();
                if (ptr0.Length() > 0)
                    {
                    if ( 0
                            == ptr0.Mid( ptr0.Length() - 1, 1 ).Compare(showKeystroke->MdcaPoint(i) ) )
                        {
                        return ETrue;
                        }
                    }
                }
            TPtrC ptr = getCurrentLeastDLTSpell();
            if ( 0 == ptr.Mid( ptr.Length() - 1, 1 ).Compare(showKeystroke->MdcaPoint(i) ) )
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
        GetKeystrokeCode(keyCode, showKeystroke->MdcaPoint(i) );
        stringBeforeLength = getCurrentLeastDLTSpell().Length();
        ptiengine->AppendKeyPress((TPtiKey)keyCode).Length();
        stringAfterLength = getCurrentLeastDLTSpell().Length();
        //the keystroke is invalid.
        if (stringBeforeLength == stringAfterLength)
            {
            return EFalse;
            }
        }
    return ETrue;
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandlEnterKey
// Handle Enter key press
// ---------------------------------------------------------------------------
//
TInt TAknFepInputMiniQwertyPinyinPhraseBase::GetCursorPos()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TInt pos = 0;
    TInt count = 0;
    TBuf<1> autoDLT;
    autoDLT.Append(KAutoDLT);

    if ( 0 == index)
        {
        pos = phraseCount;
        }
    else
        if (keystroke->Count() == index)
            {
            pos = phraseCount + showKeystroke->Count();
            }
        else
            {
            for (TInt i = 0; i < showKeystroke->Count(); ++i)
                {
                if ( 0 != showKeystroke->MdcaPoint( i ).Compare(autoDLT) )
                    {
                    count = count + 1;
                    }
                if (count == index)
                    {
                    pos = phraseCount + i + 1;
                    break;
                    }
                }
            }
    return pos;
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandlEnterKeyL
// Handle Enter key press
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandlEnterKeyL()
    {
    TBuf<KMaxKeystrokeCount> currentText;
    MAknFepUICtrlEditPane* editpane = UIContainer()->EditPaneWindow();
    CDesCArrayFlat* showkeyStoke = editpane->ShowKeystrokeArray();
    CDesCArrayFlat* phraseArray = editpane->PhraseArray();
    TInt phraseCount = phraseArray->Count();
    TInt keyStrokeCount = showkeyStoke->Count();
    TInt i = 0;
    TBuf<1> autoDLT;
    autoDLT.Append(KAutoDLT);

    for (i = 0; i < phraseCount; i++)
        {
        currentText.Append(phraseArray->MdcaPoint(i) );
        }
    for (i = 0; i < keyStrokeCount; i++)
        {
        currentText.Append(showkeyStoke->MdcaPoint(i) );
        }

    while (currentText.Find(autoDLT)> 0)
        {
        currentText.Replace(currentText.Find(autoDLT), 1, KNullDesC);
        }

    if (currentText.Length() )
        {
        MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
        fepMan->NewTextL(currentText);
        fepMan->CommitInlineEditL();
        if (keyStrokeCount == 0 && currentText.Length() > 1)
            {
            AddPhraseToDB(currentText);
            }

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

        if (fepMan->IsFlagSet(CAknFepManager::EFlagEditorFull))
            {
            fepMan->ClearFlag(CAknFepManager::EFlagEditorFull);
            iOwner->FepMan()->TryCloseUiL();
            }
        else
            {
            iOwner->FepMan()->TryCloseUiL();
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandlToneMarkL
// Handle tone mark key press.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandlSpaceKeyL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TInt showKeystrokeCount = editPane->ShowKeystrokeArray()->Count();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TBuf<1> manualDLT;
    TBuf<1> autoDLT;
    manualDLT.Append( KManualDLT );
    autoDLT.Append( KAutoDLT );
    
    TBool firstGroup = CheckFirstGroupStroke();

    keystrokeArray->InsertL(index, manualDLT);
    editPane->SetCursorIndexOfKeystroke(index + 1);
    AnalyseL();
    
    if ( editPane->ShowKeystrokeArray()->Count() > KMaxKeystrokeCount )
        {
        keystrokeArray->Delete( index );
        editPane->SetCursorIndexOfKeystroke( index );
        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
        AnalyseL();
        return;
        }
    
    //Auto change from EMiniQwertyEdit state to EEntry state. 
    if (EMiniQwertyEdit == iState)
        {
        if ( ( !firstGroup ) && CheckFirstGroupStroke() )
            {
            if ( EAutoChangeStateFromCandidate == editPane->GetAutoChangeStateFlag() )
                {
                RefreshUI();
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(ECandidate);
                }
            else if ( EAutoChangeStateFromInput == editPane->GetAutoChangeStateFlag() )
                {
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(EEntry);
                }
            else
                {
                RefreshUI();
                }
            return;
            }
        }

    //Auto change from EEntry state to EMiniQwertyEdit state.
    if (EEntry == iState)
        {
        if ( !CheckFirstGroupStroke() )
            {
            editPane->SetAutoChangeStateFlag(EAutoChangeStateFromInput);
            editPane->SetChangeState(ETrue);
            iOwner->ChangeState(EMiniQwertyEdit);
            return;
            }
        }

    RefreshUI();
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandlToneMarkL
// Handle tone mark key press.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandlToneMarkL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    TBool firstGroup = CheckFirstGroupStroke();
    AddToneMarkL();
    AnalyseL();
    //Auto change from EMiniQwertyEdit state to EEntry state. 
    if (EMiniQwertyEdit == iState)
        {
        if ( ( !firstGroup ) && CheckFirstGroupStroke() )
            {
            if ( EAutoChangeStateFromCandidate == editPane->GetAutoChangeStateFlag() )
                {
                RefreshUI();
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(ECandidate);
                }
            else if ( EAutoChangeStateFromInput == editPane->GetAutoChangeStateFlag() )
                {
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(EEntry);
                }
            else
                {
                RefreshUI();
                }
            return;
            }
        }

    //Auto change from EEntry state to EMiniQwertyEdit state.
    if (EEntry == iState)
        {
        if ( !CheckFirstGroupStroke() )
            {
            editPane->SetAutoChangeStateFlag(EAutoChangeStateFromInput);
            editPane->SetChangeState(ETrue);
            iOwner->ChangeState(EMiniQwertyEdit);
            return;
            }
        }
    RefreshUI();
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckManualDelimiter
// Check the delimiter that wether is manual delimiter.
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckManualDelimiter(
    const TInt aCount, const TDesC& aKeystroke)
    {
    TInt keyCount = 0;
    for (TInt i = 0; i < aKeystroke.Length(); ++i)
        {
        if (KManualDLT != aKeystroke[i])
            {
            keyCount = keyCount + 1;
            }
        if (aCount == keyCount)
            {
            break;
            }
        }

    if (keyCount != aCount)
        {
        return EFalse;
        }

    if (aKeystroke.Length() == keyCount)
        {
        return EFalse;
        }

    if (KManualDLT != aKeystroke[keyCount])
        {
        return EFalse;
        }

    return ETrue;
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingL
// Analyse Pinyin spelling.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingL(
    const TDesC& aKeystroke, const TDesC& aSpelling,
    CDesCArrayFlat* aShowKeystroke)
    {
    TInt count = 0;
    TBuf<1> manualDLT;
    TBuf<1> autoDLT;
    manualDLT.Append(KManualDLT);
    autoDLT.Append(KAutoDLT);

    if ( 0 == aSpelling.Compare(aKeystroke) )
        {
        for (TInt i = 0; i < aKeystroke.Length(); ++i)
            {
            aShowKeystroke->AppendL(aKeystroke.Mid(i, 1) );
            }
        return;
        }

    for (TInt i = 0; i < aSpelling.Length(); ++i)
        {
        if (KManualDLT == aSpelling[i])
            {
            //Manual delimiter
            if (CheckManualDelimiter(count, aKeystroke) )
                {
                aShowKeystroke->AppendL(manualDLT);
                }
            else
                {
                aShowKeystroke->AppendL(autoDLT);
                }
            }
        else
            {
            aShowKeystroke->AppendL(aSpelling.Mid(i, 1) );
            count = count + 1;
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingAddToneMarkL
// Analyse spelling after user press tone mark.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingAddToneMarkL(
                                               TInt aI,
                                               TInt aToneMarkCount,
                                               CDesCArrayFlat* aKeystroke,
                                               CDesCArrayFlat* aShowKeystroke )
    {
    TBuf<1> atuoDLT;
    TBuf<1> manualDLT;
    atuoDLT.Append(KAutoDLT);
    manualDLT.Append(KManualDLT);
    if ( CheckSpellingDLT( aKeystroke->MdcaPoint( aI - 1 ) ) || 
        ( KInvalidToneMark != ToneMark( aKeystroke->MdcaPoint( aI - 1 ) ) ) )
        {
        aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) ); 
        }
    else
        {
        if ( CheckSpellingAddToneMarkToPTIL( aToneMarkCount ) )
            {
            aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI - 1 ) ); 
            aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
            }
        else
            {
            if ( aShowKeystroke->Count() == 0 )
                {
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI - 1 ) ); 
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
                }
            else
                {
                if ( ( !CheckSpellingDLT(aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) && 
                    ( KInvalidToneMark == ToneMark( aShowKeystroke->
                        MdcaPoint( aShowKeystroke->Count() - 1 ) ) ) )
                    {
                    aShowKeystroke->AppendL( atuoDLT );
                    }
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI - 1 ) ); 
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingAddKeyL
// Analyse spelling after user press key that is not tone mark.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseSpellingAddKeyL(
                                            TInt& aI,
                                            TInt aDelimterPos,
                                            CDesCArrayFlat* aKeystroke,
                                            CDesCArrayFlat* aShowKeystroke )
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    TBuf<1> atuoDLT;
    TBuf<1> manualDLT;
    atuoDLT.Append(KAutoDLT);
    manualDLT.Append(KManualDLT);
    if ( 0 == aI )
        {
        if ( aI + 1 < aKeystroke->Count() )
            {
            if ( ( KInvalidToneMark != ToneMark( aKeystroke->MdcaPoint( aI + 1 ) ) ) ||
                ( CheckSpellingDLT( aKeystroke->MdcaPoint( aI + 1 ) ) ) )
                {
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI + 1 ) );
                aI = aI + 1;
                }
            else
                {
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
                aShowKeystroke->AppendL( atuoDLT );
                }
            }
        else
            {
            aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
            }
        }
    else if ( aI + 1 == aKeystroke->Count() )
        {
        if ( ( 1 == aDelimterPos ) || ( -1 == aDelimterPos ) )
            {
            if ( ( !CheckSpellingDLT( aShowKeystroke->
                    MdcaPoint( aShowKeystroke->Count() - 1 ) ) &&
                ( KInvalidToneMark == ToneMark( aShowKeystroke->
                    MdcaPoint( aShowKeystroke->Count() - 1 ) ) ) ) )
                {
                aShowKeystroke->AppendL( atuoDLT );
                }
            aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
            }
        else
            {
            for ( TInt ii = 0; ii < aDelimterPos - 1; ++ii )
                {
                aShowKeystroke->Delete( aShowKeystroke->Count() - 1 );
                }
            if ( ( !CheckSpellingDLT( aShowKeystroke->
                    MdcaPoint( aShowKeystroke->Count() - 1 ) ) ) &&
                ( KInvalidToneMark == ToneMark( aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) )
                {
                aShowKeystroke->AppendL( atuoDLT );
                }
            aI = aI - aDelimterPos;
            }
        }
    else
        {
        if ( -1 == aDelimterPos )
            {
            if ( ( !CheckSpellingDLT( aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) &&
                ( KInvalidToneMark == ToneMark( aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) )
                {
                aShowKeystroke->AppendL( atuoDLT );
                }
            if ( 0 == getCurrentLeastDLTSpell().Length() )
                {
                aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI ) );
                if ( KInvalidToneMark != ToneMark( aKeystroke->MdcaPoint( aI + 1 ) ) ) 
                    {
                    aShowKeystroke->AppendL( aKeystroke->MdcaPoint( aI + 1 ) );
                    aI = aI + 1;                            
                    }
                }
            else
                {
                aI = aI - 1;
                }
            }
        else
            {
            for ( TInt ii = 0; ii < aDelimterPos - 1; ++ii )
                {
                aShowKeystroke->Delete( aShowKeystroke->Count() - 1 );
                }
            if ( ( !CheckSpellingDLT( aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) &&
                ( KInvalidToneMark == ToneMark( aShowKeystroke->MdcaPoint( 
                    aShowKeystroke->Count() - 1 ) ) ) )
                {
                aShowKeystroke->AppendL( atuoDLT );
                }
            aI = aI - aDelimterPos;
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseL
// Analyse key storke.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::AnalyseL()
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    //user pressed keystroke sequence
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    //stroke to be shown
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    TInt start = 0;
    TInt toneMarkCount = KInvalidToneMark;
    TInt delimiterPosition = 0;
    showKeystroke->Reset();
    TBuf<1> atuoDLT;
    TBuf<1> manualDLT;
    atuoDLT.Append(KAutoDLT);
    manualDLT.Append(KManualDLT);
    TBuf<KMaxKeystrokeCount> keyTmp;

    if ( keystroke->Count() == 0 )
        {
        return;
        }

    //if the first keystroke is delimiter or ToneMark, analyse frome the next one
    if ( CheckSpellingDLT( keystroke->MdcaPoint( 0 ) ) || 
        ( KInvalidToneMark != ToneMark( keystroke->MdcaPoint( 0 ) ) ) )
        {
        showKeystroke->AppendL(keystroke->MdcaPoint( 0 ) );
        start = 1;
        }
    
    ClearPtiEngineKeystroke();
    
    for ( TInt i = start; i < keystroke->Count(); ++i )
        {
        toneMarkCount = ToneMark( keystroke->MdcaPoint( i ) );
        // current keystroke is delimiter
        if ( CheckSpellingDLT( keystroke->MdcaPoint( i ) ) )
            {
            showKeystroke->AppendL(keystroke->MdcaPoint( i ) );
            ClearPtiEngineKeystroke();
            }
        // current keystroke is tone mark
        else if ( KInvalidToneMark != toneMarkCount )
            {
            AnalyseSpellingAddToneMarkL( i, toneMarkCount, keystroke, showKeystroke );
            ClearPtiEngineKeystroke();
            }
        // current keystroke is A - Z
        else
            {
            delimiterPosition = CheckSpellingAddKeyToPTIL( keystroke->MdcaPoint( i ) );
            if ( 0 == delimiterPosition )
                {
                if ( ( 0 != i ) && 
                    ( 1 == this->getCurrentLeastDLTSpell().Length() ) )
                    {
                    if ( ( !CheckSpellingDLT( showKeystroke->
                        MdcaPoint( showKeystroke->Count() - 1 ) ) ) && 
                        ( KInvalidToneMark == ToneMark( showKeystroke->
                            MdcaPoint( showKeystroke->Count() - 1 ) ) ) )
                        {
                        showKeystroke->AppendL( atuoDLT );
                        }
                    }
                if ( i + 1 < keystroke->Count() ) 
                    {
                    if ( KInvalidToneMark == ToneMark( keystroke->MdcaPoint( i + 1 ) ) )
                        {
                        showKeystroke->AppendL( keystroke->MdcaPoint( i ) );
                        }
                    }
                else
                    {
                    showKeystroke->AppendL( keystroke->MdcaPoint( i ) );
                    }
                }
            else
                {
                AnalyseSpellingAddKeyL( i, delimiterPosition, keystroke, showKeystroke );
                ClearPtiEngineKeystroke();
                }
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleCommitL
// Handle CBA1 or select event.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandleCommitL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    TInt keyCount = editPane->KeystrokeArray()->Count();
    TInt showKeyCount = editPane->ShowKeystrokeArray()->Count();
    CDesCArrayFlat* phrase = editPane->PhraseArray();
    TInt cdtCount = uiContainer->CandidatePane()->CandidateArray()->Count();
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    if (EMiniQwertyEdit == iState)
        {
        if ( ( showKeyCount > 0 ) && (cdtCount > 0 ) )
            {
            UIContainer()->EditPaneWindow()->SetChangeState(ETrue);
            iOwner->ChangeState(ECandidate);
            return;
            }

        if ( keyCount > 0 )
            {
            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
            return;
            }
        }

    if ( ( 0 == keyCount ) && (phrase->Count() <= 1 ) )
        {
        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
        return;
        }

    if ( ( 0 == keyCount ) && (phrase->Count() > 1 ) )
        {
        TBuf<KMaxPhraseCreationCount> phraseCreated;
        for (TInt i = 0; ( (i < phrase->Count() ) && (i
                < KMaxPhraseCreationCount ) ); ++i )
            {
            phraseCreated.Append(phrase->MdcaPoint( i ) );
            AddPhraseToDB(phraseCreated);
            }
        fepMan->NewTextL(phraseCreated);
        fepMan->CommitInlineEditL();
        if ( !UIContainer()->EditPaneWindow()->GetPhraseCreationFlag() )
            {
            UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
            iOwner->PtiEngine()->SetPredictiveChineseChar(phraseCreated);
#ifdef RD_INTELLIGENT_TEXT_INPUT
            UIContainer()->EditPaneWindow()->SetChangeState(ETrue);
            if (EPtiKeyboardQwerty4x10 == iOwner->FepMan()->KeyboardLayout() ||
                 EPtiKeyboardQwerty3x11 == iOwner->FepMan()->KeyboardLayout() )
                {
                iOwner->ChangeState(EPredictiveCandidate);
                }
#endif
            }
        else
            {
            UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
            iOwner->FepMan()->TryCloseUiL();
            }
        return;
        }

    TPtrC text = UIContainer()->CandidatePane()->CurrentPhraseCandidate();
    if (text.Length() == 0)
        {
        return;
        }

    if ( !CommitInlineEEPL(text) )
        {
        DoActionAfterCommit();
        }
    else
        {
        if ( !CheckFirstGroupStroke() )
            {
            if ( iState == EEntry )
                {
                editPane->SetAutoChangeStateFlag(EAutoChangeStateFromInput);
                }
            else
                {
                editPane->SetAutoChangeStateFlag(EAutoChangeStateFromCandidate);
                }
            iOwner->ChangeState(EMiniQwertyEdit);
            return;
            }
        else
            {
            if ( iState == EEntry )
                {
                UIContainer()->EditPaneWindow()->SetChangeState( ETrue );
                iOwner->ChangeState( ECandidate );
                }
            }
        AnalyseL();
        RefreshUI();
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyBackspaceL
// Handle KeyBackspace event.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyBackspaceL(
    TKeyPressLength aLength)
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TBool firstGroup = CheckFirstGroupStroke();

    if ( ( 0 == index ) && (phraseCount != 0 ) )
        {
        RevertPhraseToKeystrokeL();
        }
    else
        if ( ( 0 == index ) && (keystroke->Count() > 0 ) )
            {
            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
            }
        else
            {
            if ( !DeleteKeystrokeL() )
                {
                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
                }
            }

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

    AnalyseL();
    //Auto change from EMiniQwertyEdit state to EEntry state. 
    if (EMiniQwertyEdit == iState)
        {
        if ( ( !firstGroup ) && CheckFirstGroupStroke() )
            {
            if ( EAutoChangeStateFromCandidate == editPane->GetAutoChangeStateFlag() )
                {
                RefreshUI();
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(ECandidate);
                }
            else if ( EAutoChangeStateFromInput == editPane->GetAutoChangeStateFlag() )
                {
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(EEntry);
                }
            else
                {
                RefreshUI();
                }
            return;
            }
        }

    //Auto change from EEntry state to EMiniQwertyEdit state.
    if (EEntry == iState)
        {
        if ( (firstGroup ) && ( !CheckFirstGroupStroke() ))
            {
            editPane->SetChangeState(EFalse);
            editPane->SetAutoChangeStateFlag(EAutoChangeStateFromInput);
            iOwner->ChangeState(EMiniQwertyEdit);
            return;
            }
        }

    RefreshUI();
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleDefaultKeyL
// Handle default key press event.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandleDefaultKeyL(TInt aKey)
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    TBool firstGroup = CheckFirstGroupStroke();

    if ( !AddKeystrokeL(aKey) )
        {
        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
        return;
        }

    AnalyseL();

    //Auto change from EMiniQwertyEdit state to EEntry state. 
    if (EMiniQwertyEdit == iState)
        {
        if ( ( !firstGroup ) && CheckFirstGroupStroke() )
            {
            if ( EAutoChangeStateFromCandidate == editPane->GetAutoChangeStateFlag() )
                {
                RefreshUI();
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(ECandidate);
                }
            else if ( EAutoChangeStateFromInput == editPane->GetAutoChangeStateFlag() )
                {
                editPane->SetChangeState(ETrue);
                iOwner->ChangeState(EEntry);
                }
            else
                {
                RefreshUI();
                }
            return;
            }
        }

    //Auto change from EEntry state to EMiniQwertyEdit state.
    if (EEntry == iState)
        {
        if ( !CheckFirstGroupStroke() )
            {
            editPane->SetAutoChangeStateFlag(EAutoChangeStateFromInput);
            editPane->SetChangeState(ETrue);
            iOwner->ChangeState(EMiniQwertyEdit);
            return;
            }
        }

    RefreshUI();
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::ShowInfoOnEEP
// Show the showinfo on the EEP ctrl.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::ShowInfoOnEEPPane()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();
    CDesCArrayFlat* phrase = editPane->PhraseArray();
    TBuf<KMaxKeystrokeCount> showInfo;
    TBuf<KMaxKeystrokeCount> keyBuf;
    for (TInt i = 0; i < phrase->Count(); ++i)
        {
        showInfo.Append(phrase->MdcaPoint(i) );
        }

    for (TInt ii = 0; ii < showKeystroke->Count(); ++ii)
        {
        showInfo.Append(showKeystroke->MdcaPoint(ii) );
        }

    for (TInt j = 0; j < keystrokeArray->Count(); ++j)
        {
        keyBuf.Append(keystrokeArray->MdcaPoint(j) );
        }

    editPane->SetTextForZhuyin(showInfo, GetCursorPos(), phrase->Count(),
        keyBuf, editPane->GetCursorIndexOfKeystroke() );

    if (iState == ECandidate)
        {
        editPane->DisableCursor();
        }
    else
        if (iState == EEntry)
            {
            editPane->EnableCursor();
            editPane->DeactiveCursor();
            }
        else
            if (iState == EMiniQwertyEdit)
                {
                editPane->EnableCursor();
                editPane->ActiveCursor();
                }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::ShowInfoOnEEP
// Show the showinfo on the EEP ctrl.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::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() && uiContainer->CandidatePane()->IsFirstPage());
        uiContainer->ShowVerticalScrollArrows(multiplePages);
        if (iState == EMiniQwertyEdit)
            {
            UIContainer()->FocusCandidatePane(EFalse);
            }
        else
            {
            UIContainer()->FocusCandidatePane(ETrue);
            UIContainer()->CandidatePane()->SelectFirstPhrase();
            }
        }
    else
        {
        uiContainer->CandidatePane()->SplitPhraseCandidatesIntoPages();
        uiContainer->CandidatePane()->SetCandidateBuffer();
        uiContainer->Enable(ETrue);
        uiContainer->ShowHorizontalScrollArrows(EFalse);
        uiContainer->ShowVerticalScrollArrows(EFalse);
        uiContainer->SetControlInVisible( EFalse );
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::GetShowKeystroke
//Handle horizontal navigation.
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::GetShowKeystroke(TInt aKey,
    TDes& aKeystroke)
    {
    TInt count = sizeof(StrokeMap )/sizeof(StrokeMap[0] );
    for (TInt i = 0; i < count; i++)
        {
        if (aKey == StrokeMap[i].iKeyCode)
            {
            aKeystroke.Append(StrokeMap[i].iValue);
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleHorizontalNavigation
//Handle horizontal navigation.
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::HandleHorizontalNavigation(
    TInt aKey)
    {
    MAknFepUICtrlCandidatePane* candidatePane = UIContainer()->CandidatePane();
    TBool response = EFalse;

    // Do navigation...
    if (aKey == EStdKeyLeftArrow)
        {
        if (!candidatePane->SelectPrev())
            {
            candidatePane->SetCandidateBuffer();
            candidatePane->SelectLastPhrase();
            }
        response = ETrue;
        }
    else
        if (aKey == EStdKeyRightArrow)
            {
            if (!candidatePane->SelectNext())
                {
                candidatePane->SetCandidateBuffer();
                candidatePane->SelectFirstPhrase();
                }
            response = ETrue;
            }

    if (response)
        {
        UpdateIndicator();
        }

    return response;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::UpdateIndicator
// Update Indicator.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::UpdateIndicator()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlCandidatePane* candidatePane = uiContainer->CandidatePane();

    if (candidatePane->IsFirstPage())
        {
        uiContainer->CandidatePane()->ShowUpScrollArrows(EFalse);
        }
    else
        {
        uiContainer->CandidatePane()->ShowUpScrollArrows(ETrue);
        }

    if (candidatePane->IsLastPage())
        {
        uiContainer->CandidatePane()->ShowDownScrollArrows(EFalse);
        }
    else
        {
        uiContainer->CandidatePane()->ShowDownScrollArrows(ETrue);
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT
    if (iOwner->FepMan()->KeyboardLayout() == EPtiKeyboardQwerty4x10)
        {
        if (candidatePane->VisibleCandidateCount()==1)
            {
            uiContainer->CandidatePane()->ShowLeftScrollArrows(EFalse);
            uiContainer->CandidatePane()->ShowRightScrollArrows(EFalse);
            }
        else
            {
            uiContainer->CandidatePane()->ShowLeftScrollArrows(ETrue);
            uiContainer->CandidatePane()->ShowRightScrollArrows(ETrue);
            }
        }
    else
        {
#endif
        if (candidatePane->SelectedIndex() == 0
                && candidatePane->IsFirstPage() )
            {
            uiContainer->CandidatePane()->ShowLeftScrollArrows(EFalse);
            }
        else
            {
            uiContainer->CandidatePane()->ShowLeftScrollArrows(ETrue);
            }

        if (candidatePane->IsLastPage() && (candidatePane->SelectedIndex()
                == candidatePane->VisibleCandidateCount() - 1))
            {
            uiContainer->CandidatePane()->ShowRightScrollArrows(EFalse);
            }
        else
            {
            uiContainer->CandidatePane()->ShowRightScrollArrows(ETrue);
            }
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT
    }
#endif    

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::DeleteMoreKeystrokeL
// Delete more keystroke than max leng.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::DeleteMoreKeystrokeL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TBuf<1> autoDLT;
    autoDLT.Append( KAutoDLT );
    AnalyseL();
    // the count keystroke more than max length.
    TInt count = showKeystroke->Count() - KMaxKeystrokeCount; 
    
    for ( TInt i = 0; i < count; ++i )
        {
        if ( 0 != showKeystroke->MdcaPoint( showKeystroke->Count() - 1 ).Compare( autoDLT ) )
            {
            showKeystroke->Delete( showKeystroke->Count() - 1 );
            keystroke->Delete( keystroke->Count() - 1 );
            }
        }
    
    if ( index > keystroke->Count() )
        {
        editPane->SetCursorIndexOfKeystroke( keystroke->Count() );
        }    
    }
// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::DeleteKeystrokeL
// Delete current keystroke.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::DeleteKeystrokeL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TInt showKeyCount = editPane->ShowKeystrokeArray()->Count();
    
    if ( ( 0 == index ) || (keystroke->Count() == 0 ))
        {
        return EFalse;
        }
    if ( 1 == index )
        {
        editPane->Reset();
        }
    if (index >= keystroke->Count() )
        {
        keystroke->Delete(keystroke->Count() - 1);
        editPane->SetCursorIndexOfKeystroke(keystroke->Count() );
        }
    else
        {
        keystroke->Delete(index - 1);
        editPane->SetCursorIndexOfKeystroke(index - 1);
        }
    
    if ( showKeyCount >= KMaxKeystrokeCount - 1 )
        {
        DeleteMoreKeystrokeL();
        }
    
    return ETrue;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AddPhraseToDB
// Add phrase to DB.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::AddPhraseToDB(
    const TDesC& aPhraseAdd)
    {
    TPtiUserDictionaryEntry addUdbEntry(aPhraseAdd);
    //Add the phrase to the DB by PTI Engine
    iOwner->PtiEngine()->AddUserDictionaryEntry(addUdbEntry);
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::RefreshCandidate
// Refresh candidate
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::RefreshCandidate()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    uiContainer->CandidatePane()->SetCandidateBuffer();
    uiContainer->Enable(ETrue);

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

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

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckKeyNeedRepeat
//  Check key whether need repeat.
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckKeyNeedRepeat(
    TKeyPressLength aLength)
    {
    MAknFepUICtrlEditPane* editPane = UIContainer()->EditPaneWindow();
    if (editPane->IsChangeState() && aLength == ELongKeyPress)
        {
        return EFalse;
        }
    else
        {
        editPane->SetChangeState(EFalse);
        }
    return ETrue;
    }

// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CommitInlineEEPL
// Commint text to EEP or editor
// ---------------------------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CommitInlineEEPL(
    const TDesC& aDes)
    {
    TInt charCount = aDes.Length();
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
    MAknFepUICtrlEditPane* editpane = UIContainer()->EditPaneWindow();
    CDesCArrayFlat* showkeyStoke = editpane->ShowKeystrokeArray();
    CDesCArrayFlat* keyStoke = editpane->KeystrokeArray();
    CDesCArrayFlat* phraseArray = editpane->PhraseArray();
    CDesCArrayFlat* phraseShowKeyStroke = editpane->PhraseShowKeyStrokeArray();
    TBuf<KMaxKeystrokeCount> buf;
    TBuf<1> autoDLT;
    autoDLT.Append(KAutoDLT);

    if (phraseArray->Count() == 0)
        {
        editpane->SetPhraseCreationFlag(EFalse);
        }
    phraseArray->AppendL(aDes);

    TInt delCount = 0;
    for (TInt i = 0; i < showkeyStoke->Count() && charCount
            && keyStoke->Count() != 0; i++)
        {
        TPtrC showptr = showkeyStoke->MdcaPoint(i);
        TPtrC ptr = keyStoke->MdcaPoint( 0);
        if (CheckSpellingDLT(showptr) || (KInvalidToneMark
                != ToneMark(showptr) ))
            {
            charCount--;
            }
        if (showptr.Compare(autoDLT) != 0)
            {
            buf.Append(ptr);
            keyStoke->Delete( 0);
            }
        delCount++;
        }
    
	for (TInt j = 0; j < delCount; j++)
		{
		showkeyStoke->Delete( 0);
		}
	phraseShowKeyStroke->AppendL(buf);
	
    TInt phraseCount = phraseArray->Count();
    if (phraseCount > KMaxPhraseCreationCount)
        {
        phraseCount = KMaxPhraseCreationCount;
        }

    if (keyStoke->Count() == 0 || phraseCount == KMaxPhraseCreationCount)
        {
		//here,we pass pinyin-spelling to db together with phrase.
		TBuf<KMaxPhraseCreationCount> phraseCreated;
		phraseCreated.FillZ();
		TBuf<(1+KMaxSpellLength)*KMaxPhraseCreationCount> phraseCreatedWithPinYin;//(Zi+pinyin)* max_Zi
		phraseCreatedWithPinYin.FillZ();
		for (TInt ii = 0; ii < phraseCount; ++ii)
			{
			TPtrC ptrZi = phraseArray->MdcaPoint(ii);
			phraseCreatedWithPinYin.Append(ptrZi);
			phraseCreated.Append(ptrZi);
			
			TPtrC ptrPinYin = phraseShowKeyStroke->MdcaPoint(ii);//it mabe include KManualDLT,but no matter
			phraseCreatedWithPinYin.Append(ptrPinYin);
			
			TInt zeroTail = (1+KMaxSpellLength)-(ptrZi.Length()+ptrPinYin.Length());
			phraseCreatedWithPinYin.AppendFill(0,zeroTail);
			
			}
		fepMan->NewTextL(phraseCreated);
		fepMan->CommitInlineEditL();
		iOwner->PtiEngine()->SetPredictiveChineseChar(phraseCreated);
		AddPhraseToDB(phraseCreatedWithPinYin);
		return EFalse;
        }

    

    editpane->SetCursorIndexOfKeystroke( 0);
    editpane->DisableCursor();
    editpane->SetPhraseCreationFlag(ETrue);
    return ETrue;
    }
// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::ClearPtiEngineKeystroke
// clear the ptiengine keystroke;
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::ClearPtiEngineKeystroke()
    {
    iOwner->PtiEngine()->ClearCurrentWord();
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AddKeystrokeL
// Add keystroke.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::AddKeystrokeL(TInt aKey)
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TInt showKeystrokeCount = editPane->ShowKeystrokeArray()->Count();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TBuf<1> keystroke;
    
    if ( phraseCount + showKeystrokeCount >= KMaxKeystrokeCount )
        {
        return EFalse;
        }

    GetShowKeystroke(aKey, keystroke);
    if ( index >= keystrokeArray->Count() )
        {
        keystrokeArray->AppendL(keystroke);
        editPane->SetCursorIndexOfKeystroke(keystrokeArray->Count() );
        }
    else
        {
        keystrokeArray->InsertL(index, keystroke);
        editPane->SetCursorIndexOfKeystroke(index + 1);
        }
    
    if ( phraseCount + showKeystrokeCount >= KMaxKeystrokeCount - 1 )
        {
        AnalyseL();
        if ( phraseCount + editPane->ShowKeystrokeArray()->Count() <= KMaxKeystrokeCount )
            {
            return ETrue;
            }
        else
            {
            keystrokeArray->Delete( index );
            editPane->SetCursorIndexOfKeystroke( index );
            AnalyseL();
            return EFalse;
            }
        }
        

    return ETrue;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::AddToneMarkL
// Add tone mark.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::AddToneMarkL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TInt showKeystrokeCount = editPane->ShowKeystrokeArray()->Count();
    TInt index = editPane->GetCursorIndexOfKeystroke();
    TInt i = 0;
    const TInt MaxToneMark = 4;
    if ( phraseCount + showKeystrokeCount >= KMaxKeystrokeCount )
        {
        if ( 0 == index )
            {
            return EFalse;
            }
        else
            {
            if ( KInvalidToneMark == ToneMark( keystrokeArray->MdcaPoint( index - 1 ) ) )
                {
                return EFalse;
                }
            }
        }

    TBuf<1> toneMark;

    if ( 0 == index )
        {
        toneMark.Append(PinyinToneMap[0].iValue);
        keystrokeArray->InsertL( 0, toneMark);
        editPane->SetCursorIndexOfKeystroke( 1);
        return ETrue;
        }
    
    TInt num = sizeof(PinyinToneMap )/( sizeof(PinyinToneMap[0]));
    for ( i = 0; i < num; ++i )
        {
        if (PinyinToneMap[i].iValue == keystrokeArray->MdcaPoint( index - 1 )[0])
            {
            break;
            }
        }

    if ( i > MaxToneMark )
        {
        toneMark.Append(PinyinToneMap[0].iValue);
        keystrokeArray->InsertL(index, toneMark);
        editPane->SetCursorIndexOfKeystroke( index + 1 );
        }
    else
        {
        if ( MaxToneMark == i )
            {
            toneMark.Append(PinyinToneMap[0].iValue);
            }
        else
            {
            toneMark.Append(PinyinToneMap[ i + 1 ].iValue);
            }
        keystrokeArray->Delete(index - 1);
        keystrokeArray->InsertL(index - 1, toneMark);
        }

    if ( phraseCount + showKeystrokeCount >= KMaxKeystrokeCount - 1 )
        {
        AnalyseL();
        if ( phraseCount + editPane->ShowKeystrokeArray()->Count() > KMaxKeystrokeCount )
            {
            if ( i > MaxToneMark )
                {
                keystrokeArray->Delete( index );
                editPane->SetCursorIndexOfKeystroke( index );
                }
            else
                {
                toneMark.Zero();
                toneMark.Append( PinyinToneMap[i].iValue );
                keystrokeArray->Delete( index - 1 );
                keystrokeArray->InsertL( index - 1, toneMark );
                }
            AnalyseL();
            return EFalse;
            }
        }
        
    return ETrue;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::GetCandidateL
// Get the candidate info.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::GetCandidateL()
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* phraseCandidates = 
        uiContainer->CandidatePane()->CandidateArray();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    phraseCandidates->Reset();
    TBuf<KMaxKeystrokeCount> buf;
    TBuf<1> delimiter;
    delimiter.Append( KManualDLT );
    TInt keyCode;
    TInt count = KInvalidToneMark;
    ClearPtiEngineKeystroke();
    
    if ( showKeystroke->Count() == 0 )
        {
        return;
        }

    if ( CheckAllGroupStroke() && ( phraseCount == 0 ) )
        {
        getCurrentLeastDLTSpell();
        ptiengine->GetChinesePhraseCandidatesL( *phraseCandidates ); 
        return;
        }
    
    if ( CheckFirstGroupStroke() )
        {
        ClearPtiEngineKeystroke();
        for ( TInt i = 0; i < showKeystroke->Count(); ++i )
            {
            count = ToneMark( keystroke->MdcaPoint( i ) );
            if ( CheckSpellingDLT( showKeystroke->MdcaPoint( i ) ) )
                {
                break;
                }
            else if ( KInvalidToneMark != count )
                {
                for ( TInt j = 0; j < count; ++j )
                    {
                    ptiengine->IncrementToneMark( ETrue );
                    }
                break;
                }
            else
                {
                GetKeystrokeCode( keyCode, keystroke->MdcaPoint( i ) );
                ptiengine->AppendKeyPress((TPtiKey)keyCode);
                }
            }
        }
    else
        {
        return;
        }
    getCurrentLeastDLTSpell();
    ptiengine->GetChinesePhraseCandidatesL( *phraseCandidates );
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::GetKeystrokeCode
// get Code of the key stroke. 
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::GetKeystrokeCode(TInt& aKey,
    const TDesC& aKeystroke)
    {
    TInt count = sizeof(StrokeMap )/sizeof(StrokeMap[0] );
    for (TInt i = 0; i < count; i++)
        {
        TBuf<1> buf;
        buf.Append(StrokeMap[i].iValue);
        if (0 == aKeystroke.Compare(buf))
            {
            aKey = StrokeMap[i].iKeyCode;
            break;
            }
        }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::RevertPhraseToKeystrokeL
// Revert the phrase to keystroke.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::RevertPhraseToKeystrokeL()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystrokeArray = editPane->KeystrokeArray();
    CDesCArrayFlat* shownKeystrokeArray = editPane->ShowKeystrokeArray();
    CDesCArrayFlat* phrase = editPane->PhraseArray();
    CDesCArrayFlat* phraseStroke = editPane->PhraseShowKeyStrokeArray();
    TBuf<KMaxKeystrokeCount> buf;
    if ( (phrase->Count() == 0 ) || (phraseStroke->Count() == 0 ))
        {
        return;
        }

    buf.Append(phraseStroke->MdcaPoint(phraseStroke->Count() - 1) );
    for (TInt i = buf.Length() - 1; i >= 0; --i)
        {
        keystrokeArray->InsertL( 0, buf.Mid(i, 1) );
        }
    phrase->Delete(phrase->Count() - 1);
    phraseStroke->Delete(phraseStroke->Count() - 1);
    AnalyseL();
    TInt showCount = editPane->ShowKeystrokeArray()->Count();
    TInt leng = phrase->Count() + showCount;
    TInt deleteCount = 0;
    if (leng > KMaxKeystrokeCount)
        {
        for (TInt i = 0; i < leng - KMaxKeystrokeCount; ++i)
            {
            if (KAutoDLT != shownKeystrokeArray->MdcaPoint( shownKeystrokeArray->Count() - 1 )[0])
                {
                deleteCount = deleteCount + 1;
                }
            shownKeystrokeArray->Delete(shownKeystrokeArray->Count() - 1);
            }
        if (KAutoDLT == shownKeystrokeArray->MdcaPoint( shownKeystrokeArray->Count() - 1 )[0])
            {
            shownKeystrokeArray->Delete(shownKeystrokeArray->Count() - 1);
            }
        }
    for (TInt i = 0; i < deleteCount; ++i)
        {
        keystrokeArray->Delete(keystrokeArray->Count() - 1);
        }

    editPane->SetCursorIndexOfKeystroke(buf.Length() );
    keystrokeArray->Compress();
    phrase->Compress();
    phraseStroke->Compress();

    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::SetWarningColor
// Set warning color.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::SetWarningColor(
                                           TInt aCount,
                                           TInt aIndex,
                                           TInt aI,
                                           TInt aPhraseCount,
                                           TInt aToneMark,
                                           TBool aValid,
                                           CDesCArrayFlat* aShowKeystroke
                                           )
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlEditPane* editPane = UIContainer()->EditPaneWindow();
    if ( ( !aValid ) || CheckSpellingDLT(aShowKeystroke->MdcaPoint(aI
            - 1) ) || (KInvalidToneMark
            != ToneMark( aShowKeystroke->MdcaPoint( aI - 1 ) ) ))
        {
        editPane->SetHighlight(aPhraseCount + aIndex, aPhraseCount
                + aIndex + aCount - 1 );
        }
    else
        {
        TPtrC ptr1 = getCurrentLeastDLTSpell();
        for (TInt j = 0; j < aToneMark; ++j)
            {
            ptiengine->IncrementToneMark(ETrue);
            TPtrC ptr0 = getCurrentLeastDLTSpell();
            if (ptr0.Length() > 0)
                {
                if ( 0 == ptr0.Mid( ptr0.Length() - 1, 1 ).
                Compare(aShowKeystroke->MdcaPoint( aI ) ) )
                    {
                    break;
                    }
                }
            }
        TPtrC ptr2 = getCurrentLeastDLTSpell();
        if ( ( ( 1 + ptr1.Length() ) != ptr2.Length() ) || ( 0
                != ptr2.Mid( ptr2.Length() - 1, 1 ).
                CompareC( aShowKeystroke->MdcaPoint( aI ) ) ))
            {
            editPane->SetHighlight( aPhraseCount + aIndex, aPhraseCount
                    + aIndex + aCount - 1);
            }
        }
    ClearPtiEngineKeystroke();
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::SetWarningColor
// Set warning color.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::SetWarningColor()
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlEditPane* editPane = UIContainer()->EditPaneWindow();
    CDesCArrayFlat* showKeystroke = editPane->ShowKeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TBool valid = ETrue;
    TInt index = 0;
    TInt count = 0;
    TInt stringBeforeLength = 0;
    TInt stringAfterLength = 0;
    TInt start = 0;
    TInt keyCode = 0;
    TInt toneMark = KInvalidToneMark;

    if (showKeystroke->Count() == 0)
        {
        return;
        }

    if (CheckAllGroupStroke() )
        {
        return;
        }
    ClearPtiEngineKeystroke();
    if (CheckSpellingDLT(showKeystroke->MdcaPoint( 0) ) || (KInvalidToneMark
            != ToneMark(showKeystroke->MdcaPoint( 0) ) ))
        {
        start = 1;
        editPane->SetHighlight(phraseCount, phraseCount);
        index = 1;
        }

    for ( TInt i = start; i < showKeystroke->Count(); ++i )
        {
        count = count + 1;
        // tone mark
        toneMark = ToneMark(showKeystroke->MdcaPoint(i) );
        if ( KInvalidToneMark != toneMark )
            {
            SetWarningColor( count, 
                             index, 
                             i, 
                             phraseCount, 
                             toneMark, 
                             valid, 
                             showKeystroke );
            index = i + 1;
            count = 0;
            valid = ETrue;
            }
        else
            if ( CheckSpellingDLT(showKeystroke->MdcaPoint(i) ) )
                {
                if ( ( !valid )
                        || CheckSpellingDLT(showKeystroke->MdcaPoint(i - 1) )
                        || (KInvalidToneMark
                                != ToneMark(showKeystroke->MdcaPoint(i - 1) ) ))
                    {
                    editPane->SetHighlight(phraseCount + index, phraseCount
                            + index + count - 1);
                    }
                ClearPtiEngineKeystroke();
                index = i + 1;
                count = 0;
                valid = ETrue;
                }
            else
                {
                if ( valid )
                    {
                    GetKeystrokeCode(keyCode, showKeystroke->MdcaPoint(i) );
                    stringBeforeLength = getCurrentLeastDLTSpell().Length();
                    ptiengine->AppendKeyPress((TPtiKey)keyCode).Length();
                    stringAfterLength = getCurrentLeastDLTSpell().Length();
                    if ( stringBeforeLength == stringAfterLength )//the keystroke is invalid
                        {
                        ClearPtiEngineKeystroke();
                        valid = EFalse;
                        }
                    }
                }

        if ( ( showKeystroke->Count() == i + 1 ) && ( !valid ) )
            {
            editPane->SetHighlight(
                                phraseCount + index, 
                                phraseCount + index + count - 1 );
            ClearPtiEngineKeystroke();
            }
        }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::SetWarningColor
// Set warning color.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::ChangeCbaL()
    {
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan( );
    MAknFepUICtrlEditPane* editPane = UIContainer()->EditPaneWindow( );
    TInt candidateCount = UIContainer()->CandidatePane()->CandidateArray()->Count( );
    TInt keyStrokeCount = editPane->KeystrokeArray()->Count( );
    TInt phraseCount = editPane->PhraseArray()->Count( );
    TInt currentCBAResId = editPane->GetCurrentCBAResID( );
    if ( (candidateCount == 0 && keyStrokeCount != 0 ) || (phraseCount == 1
        && keyStrokeCount == 0 ) )
        {
        if ( R_AKNFEP_SOFTKEYS_EMPTY_CANCEL_EMPTY != currentCBAResId )
            {
            fepMan->UpdateCbaL( R_AKNFEP_SOFTKEYS_EMPTY_CANCEL_EMPTY );
            editPane->SetCurrentCBAResID( R_AKNFEP_SOFTKEYS_EMPTY_CANCEL_EMPTY );
            }

        }
    else if ( keyStrokeCount == 0 )
        {
        if ( R_AKNFEP_SOFTKEYS_DONE_CANCEL_DONE != currentCBAResId )
            {
            fepMan->UpdateCbaL( R_AKNFEP_SOFTKEYS_DONE_CANCEL_DONE );
            editPane->SetCurrentCBAResID( R_AKNFEP_SOFTKEYS_DONE_CANCEL_DONE );
            }
        }
    else if ( R_AKNFEP_SOFTKEYS_OK_SELECT_CANCEL != currentCBAResId )
        {
        fepMan->UpdateCbaL( R_AKNFEP_SOFTKEYS_OK_SELECT_CANCEL );
        editPane->SetCurrentCBAResID( R_AKNFEP_SOFTKEYS_OK_SELECT_CANCEL );
        }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::MoveCursorLeft
// Move the cursor to Left.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::MoveCursorLeft()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* showKeyStoke = editPane->ShowKeystrokeArray();
    TInt showKeyStokeCount = editPane->ShowKeystrokeArray()->Count();
    TInt indexOfKeystroke = editPane->GetCursorIndexOfKeystroke();
    TInt cursorPos = editPane->GetCursor() - editPane->PhraseArray()->Count();

    TBuf<1> autoDLT;
    autoDLT.Append(KAutoDLT);
    const TInt offset = 2;
    if (cursorPos <= 0)
        {
        cursorPos = 0;
        }
    else
        if (cursorPos >= showKeyStokeCount)
            {
            cursorPos = showKeyStokeCount;
            }

    if (cursorPos == 0)
        {
        editPane->SetCursorIndexOfKeystroke(editPane->KeystrokeArray()->Count() );
        ShowInfoOnEEPPane();
        SetWarningColor();
        }
    else
        if (cursorPos == 1)
            {
            editPane->SetCursorIndexOfKeystroke( 0);
            ShowInfoOnEEPPane();
            SetWarningColor();
            }
        else
            {
            if (showKeyStoke->MdcaPoint( cursorPos - 2 ).Compare(autoDLT) == 0)
                {
                editPane->MoveCursorLeft(offset);
                editPane->SetCursorIndexOfKeystroke(indexOfKeystroke - 1);
                }
            else
                {
                editPane->MoveCursorLeft();
                editPane->SetCursorIndexOfKeystroke(indexOfKeystroke - 1);
                }
            }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::MoveCursorRight
// Move the cursor to Right.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::MoveCursorRight()
    {
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* showKeyStoke = editPane->ShowKeystrokeArray();
    TInt showKeyStokeCount = editPane->ShowKeystrokeArray()->Count();
    TInt indexOfKeystroke = editPane->GetCursorIndexOfKeystroke();
    TInt cursorPos = editPane->GetCursor() - editPane->PhraseArray()->Count();
    TBuf<1> autoDLT;
    autoDLT.Append(KAutoDLT);
    const TInt offset = 2;

    if (cursorPos <= 0)
        {
        cursorPos = 0;
        }
    else
        if (cursorPos >= showKeyStokeCount)
            {
            cursorPos = showKeyStokeCount;
            }

    if (cursorPos == showKeyStokeCount)
        {
        editPane->SetCursorIndexOfKeystroke( 0);
        ShowInfoOnEEPPane();
        SetWarningColor();
        }
    else
        if (cursorPos == showKeyStokeCount - 1)
            {
            editPane->MoveCursorRight();
            editPane->SetCursorIndexOfKeystroke(editPane->KeystrokeArray()->Count() );
            ShowInfoOnEEPPane();
            SetWarningColor();
            }
        else
            {
            if (showKeyStoke->MdcaPoint( cursorPos ).Compare(autoDLT) == 0)
                {
                editPane->MoveCursorRight(offset);
                editPane->SetCursorIndexOfKeystroke(indexOfKeystroke + 1);
                }
            else
                {
                editPane->MoveCursorRight();
                editPane->SetCursorIndexOfKeystroke(indexOfKeystroke + 1);
                }
            }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpecialKey
// Check the special keystroke( i,u,v ).
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpecialKey(const TInt aKey)
    {
    if ( (aKey == EPtiKeyQwertyI ) || (aKey == EPtiKeyQwertyU ) || (aKey
            == EPtiKeyQwertyV ))
        {
        return ETrue;
        }
    return EFalse;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpellingDLT
// Check the delimiter of spelling.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpellingDLT(
    const TDesC& aKeystroke)
    {
    if ( aKeystroke.Length() == 0 )
        {
        return EFalse;
        }
    
    if ( ( KAutoDLT == aKeystroke[0] ) || ( KManualDLT == aKeystroke[0] ) )
        {
        return ETrue;
        }
    
    return EFalse;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::ToneMark
// Get pinyin tone mark.
// ---------------------------------------------------------
//
TInt TAknFepInputMiniQwertyPinyinPhraseBase::ToneMark(const TDesC& aKeystroke)
    {
    TInt numOfToneMark = sizeof (PinyinToneMap)/sizeof(PinyinToneMap[0]);
    for (TInt i = 0; i < numOfToneMark; i++)
        {
        if (PinyinToneMap[i].iValue == aKeystroke[0])
            return PinyinToneMap[i].iInputTone;
        }
    return KInvalidToneMark;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::ToneMark
// Get pinyin tone mark.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpellingAddToneMarkToPTIL(
                                                        const TInt aToneMark )
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    TBuf<1> toneMark;
    TBuf<1> delimiter;
    
    toneMark.Append( PinyinToneMap[aToneMark - 1].iValue );
    delimiter.Append( KManualDLT );
    
    for ( TInt i = 0; i < aToneMark; ++i )
        {
        ptiengine->IncrementToneMark(ETrue);
        TPtrC ptr = getCurrentLeastDLTSpell();
        if ( ( 0 == ptr.Mid( ptr.Length() - 1, 1 ).Compare( toneMark ) ) &&
            ( KErrNotFound == ptr.Find( delimiter ) )
            )
            {
            return ETrue;
            }
        }

    
    return EFalse;
    }
TPtrC TAknFepInputMiniQwertyPinyinPhraseBase::getCurrentLeastDLTSpell()
	{
	CPtiEngine* ptiengine = iOwner->PtiEngine();
	CDesC16ArrayFlat* allSpell = new CDesC16ArrayFlat(1);
	TPtrC  currentSpell;
	TBuf<1> delimiter;
	TBuf<KMaxKeystrokeCount> preDltPosizeArr;
	TBuf<KMaxKeystrokeCount> curDltPosizeArr;
	preDltPosizeArr.FillZ(KMaxKeystrokeCount);
	preDltPosizeArr.SetLength(KMaxKeystrokeCount);
	curDltPosizeArr.FillZ(KMaxKeystrokeCount);
	curDltPosizeArr.SetLength(KMaxKeystrokeCount);
	
	TInt index = 1;
	delimiter.Append( KManualDLT );
	TRAP_IGNORE( ptiengine->GetPhoneticSpellingsL(*allSpell));
	TInt allCount = ptiengine->PhoneticSpellingCount();
	
	
	for( TInt i = 0; i < allCount; i++)
		{
		
		currentSpell.Set(allSpell->MdcaPoint(i));
		TInt dltIndex = 0;
		curDltPosizeArr.FillZ(KMaxKeystrokeCount);
		curDltPosizeArr.SetLength(KMaxKeystrokeCount);
		TInt preIndex = 0;
		for (TInt j = 0; j < currentSpell.Length(); j++)
			{
		
			if (currentSpell.Mid(j, 1).Compare(delimiter) == 0 )
				{	
				curDltPosizeArr[dltIndex] = j - preIndex - 1;
				preIndex = j;
				dltIndex++;
				}
			else if ((j+1) == currentSpell.Length())
				{
				curDltPosizeArr[dltIndex] = j - preIndex;
				}
			
			}
		
		for (TInt k = 0; k < KMaxKeystrokeCount; k++)
			{
			
			if (preDltPosizeArr[k] < curDltPosizeArr[k] )
				{
				preDltPosizeArr.Copy(curDltPosizeArr);
				index = i + 1;
				break;
				}
			else if (preDltPosizeArr[k] > curDltPosizeArr[k] )
				{
				break;
				}
			}
			
		}
	
	if (allSpell)
		{
		delete allSpell;
		}
	ptiengine->SelectPhoneticSpelling( index );
	return ptiengine->GetPhoneticSpelling(index);
	
	}
// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpellingAddKeyToPTIL
// Check the spelling after add key to the PTI.
// ---------------------------------------------------------
//
TInt TAknFepInputMiniQwertyPinyinPhraseBase::CheckSpellingAddKeyToPTIL(
                                                     const TDesC& aKeystroke )
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    
    TBuf<1> delimiter;
    TInt keyCode = 0;
    TInt stringBeforeLength = 0;
    TInt stringAfterLength = 0;
    TInt delimiterIndex = 0;
    delimiter.Append( KManualDLT );
    
    GetKeystrokeCode( keyCode, aKeystroke );
    //get the string before append this keystroke
    TPtrC ptr = getCurrentLeastDLTSpell();
    stringBeforeLength = ptr.Length();
    //get the string after append this keystroke
    ptiengine->AppendKeyPress((TPtiKey)keyCode);
    TPtrC ptr1 = getCurrentLeastDLTSpell();
    stringAfterLength = ptr1.Length();
    
    if ( stringBeforeLength != stringAfterLength )
        {
        TPtrC ptr = getCurrentLeastDLTSpell();
        if ( KErrNotFound == ptr.Find( delimiter ) )
            {
            return 0;
            }
        else
            {
            delimiterIndex = ptr.Length() - ptr.Find( delimiter ) - 1;
            return delimiterIndex;
            }
        }
    else
        {
        return -1;
        }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyFromCandidateL
// Handle key from candidate.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandleKeyFromCandidateL(
    TInt aKey, TKeyPressLength /*aLength*/)
    {
    TInt index = 0;
#ifdef RD_INTELLIGENT_TEXT_INPUT
    // it may be one of the 'valid' numbers..
    TPtiKeyboardType keyboardtype = iOwner->FepMan()->KeyboardLayout();
    if (EPtiKeyboardQwerty4x10 == keyboardtype || EPtiKeyboardQwerty3x11
            == keyboardtype || EPtiKeyboardHalfQwerty == keyboardtype
            || EPtiKeyboardCustomQwerty == keyboardtype)
        {
        MPtiLanguage *lang= NULL;
        RArray <TPtiNumericKeyBinding> keybinding;
        TBool validnumkey = EFalse;
        CPtiEngine* ptiengine = iOwner->PtiEngine();
        
        if( ptiengine != NULL )
            {
            lang = ptiengine->CurrentLanguage();
            }
        if (ptiengine && lang)
            {
            TRAP_IGNORE(ptiengine->GetNumericModeKeysForQwertyL(lang->LanguageCode(), keybinding, keyboardtype));
            TInt numericKeysCount = keybinding.Count();
            while (numericKeysCount--)
                {
                TPtiNumericKeyBinding numKeyBind =
                        keybinding[numericKeysCount];
                if ( (numKeyBind.iChar >= 0x31 && numKeyBind.iChar <= 0x36)
                        &&(aKey == numKeyBind.iKey))
                    {
                    index = numKeyBind.iChar - EPtiKey0 -1;
                    validnumkey = ETrue;
                    break;
                    }
                }
            }
        keybinding.Reset();
        keybinding.Close();
        if ( !validnumkey)
            {
            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);
            return;
            }
        }
    else
        {
#endif
        index = MapKeyToIndex(aKey);
#ifdef RD_INTELLIGENT_TEXT_INPUT
        }
#endif
    MAknFepUICtrlCandidatePane* candidatePane = UIContainer()->CandidatePane();

    if (candidatePane->SelectIndex(index) || aKey == EStdKeyDevice3 || aKey
            == EStdKeyEnter)
        {
        TPtrC text = candidatePane->CurrentPhraseCandidate();
        if (text.Length() )
            {
            if ( !CommitInlineEEPL(text) )
                {
                DoActionAfterCommit();
                }
            else
                {
                if (CheckFirstGroupStroke() )
                    {
                    RefreshUI(EFalse);
                    UIContainer()->CandidatePane()->SelectFirstPhrase();
                    }
                else
                    {
                    UIContainer()->EditPaneWindow()->SetAutoChangeStateFlag(EAutoChangeStateFromCandidate);
                    iOwner->ChangeState(EMiniQwertyEdit);
                    }
                }
            }
        }
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::CheckAllGroupStroke
// check the all group stroke of keystroke.
// ---------------------------------------------------------
//
TBool TAknFepInputMiniQwertyPinyinPhraseBase::CheckAllGroupStroke()
    {
    CPtiEngine* ptiengine = iOwner->PtiEngine();
    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();
    MAknFepUICtrlEditPane* editPane = uiContainer->EditPaneWindow();
    CDesCArrayFlat* keystroke = editPane->KeystrokeArray();
    TInt phraseCount = editPane->PhraseArray()->Count();
    TInt keyCode = 0;
    TInt stringBeforeLength = 0;
    TInt stringAfterLength = 0;
    TInt toneMarkCount = KInvalidToneMark;

    ClearPtiEngineKeystroke();

    //If there is phrase on the entry pane then the all keystroke is invalid.
    if ( phraseCount > 0 )
        {
        return EFalse;
        }

    //If the first keystroke is delimiter or tone mark 
    //then all keystroke is invalid.
    if ( ( keystroke->Count() == 0 )
            || (CheckSpellingDLT(keystroke->MdcaPoint( 0 ) ) )
            || (KInvalidToneMark != ToneMark(keystroke->MdcaPoint( 0 ) ) ) )
        {
        return EFalse;
        }

    for (TInt i = 0; i < keystroke->Count(); ++i )
        {
        toneMarkCount = ToneMark(keystroke->MdcaPoint( i ) );
        if ( KInvalidToneMark != toneMarkCount )
            {
            if ( (CheckSpellingDLT(keystroke->MdcaPoint( i - 1 ) ) )
                    || (KInvalidToneMark != ToneMark(keystroke->MdcaPoint( i - 1 ) ) ) )
                {
                return EFalse;
                }
            for (TInt j =0; j < toneMarkCount; ++j)
                {
                ptiengine->IncrementToneMark(ETrue);
                TPtrC ptr1 = getCurrentLeastDLTSpell();
                if (ptr1.Length() > 0)
                    {
                    if ( 0 == ptr1.Mid( ptr1.Length() - 1 ).Compare(keystroke->MdcaPoint( i ) ) )
                        {
                        break;
                        }
                    }
                }
            TPtrC ptr = getCurrentLeastDLTSpell();
            if ( 0 != ptr.Mid( ptr.Length() - 1, 1 ).Compare(keystroke->MdcaPoint( i ) ) )
                {
                return EFalse;
                }
            }
        else
            {
            if ( (CheckSpellingDLT(keystroke->MdcaPoint( i ) ) )
                    && (KInvalidToneMark != ToneMark(keystroke->MdcaPoint( i - 1 ) ) ) )
                {
                return EFalse;
                }
            GetKeystrokeCode(keyCode, keystroke->MdcaPoint(i) );
            stringBeforeLength = getCurrentLeastDLTSpell().Length();
            ptiengine->AppendKeyPress((TPtiKey)keyCode).Length();
            stringAfterLength = getCurrentLeastDLTSpell().Length();
            if ( stringBeforeLength == stringAfterLength )
                {
                return EFalse;
                }
            }
        }

    return ETrue;
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::DoActionAfterCommit
// Do action afer commit, change state to predictive or not.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::DoActionAfterCommit()
    {
    TRAP_IGNORE( DoActionAfterCommitL() );
    }

// ---------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::DoActionAfterCommitL
// Do action afer commit, change state to predictive or not.
// ---------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::DoActionAfterCommitL()
    {
    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();
    if (fepMan->IsFlagSet(CAknFepManager::EFlagEditorFull) )
        {
        UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
        fepMan->ClearFlag(CAknFepManager::EFlagEditorFull);
        UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
        if (UIContainer()->EditPaneWindow()->KeystrokeArray()->Count() != 0)
            {
            UIContainer()->EditPaneWindow()->ResetAllArray();
            UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
            CAknWarningNote* errnote = new( ELeave ) CAknWarningNote();
            errnote->SetTone(CAknNoteDialog::EWarningTone);
            errnote->ExecuteLD(KMaxPhraseNote);
            }
        iOwner->FepMan()->TryCloseUiL();
        }
    else
        {
        if (UIContainer()->EditPaneWindow()->KeystrokeArray()->Count() != 0)
            {
            UIContainer()->EditPaneWindow()->ResetAllArray();
            UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
            CAknWarningNote* errnote = new( ELeave ) CAknWarningNote();
            errnote->SetTone(CAknNoteDialog::EWarningTone);
            errnote->ExecuteLD(KMaxPhraseNote);
            }
        else
            {
            UIContainer()->EditPaneWindow()->ResetAllArray();
            if ( !UIContainer()->EditPaneWindow()->GetPhraseCreationFlag() )
                {
                UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
                UIContainer()->EditPaneWindow()->SetChangeState(ETrue);
                iOwner->ChangeState(EPredictiveCandidate);
                }
            else
                {
                UIContainer()->EditPaneWindow()->SetPhraseCreationFlag(EFalse);
                iOwner->FepMan()->TryCloseUiL();
                }
            }
        }
    }
// ---------------------------------------------------------------------------
// TAknFepInputMiniQwertyPinyinPhraseBase::HandleCommandL
// Handling Command
// ---------------------------------------------------------------------------
//
void TAknFepInputMiniQwertyPinyinPhraseBase::HandleCommandL( TInt aCommandId )
    {
    switch ( aCommandId )
        {
        // Handle the event frome command.
        case EAknSoftkeySelect:
            //case (TUint16)EAknSoftkeySelect: //the Selected in soft CBA
            HandleCommitL( );
            break;
        default:
            TAknFepInputStateChineseBase::HandleCommandL( aCommandId );
            break;
        }
    }
// End of file
