/*

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