/*

* Copyright (c) 2003-2005 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 CAknFepUIManagerChinese methods.

*

*/

// INCLUDE FILES

#include <e32svr.h> // RDebug stuff...

#include <e32keys.h>

#include "AknFepUiManagerBase.h"

#include "AknFepUiManagerChinese.h"

#include "AknFepManagerUIInterface.h"

#include "AknFepGlobalEnums.h"

#include "AknFepUiCtrlContainerChinese.h"

#include "AknFepUICtrlInputPane.h"

#include "AknFepUICtrlCandidatePane.h"

#include "AknFepUICtrlPinyinPopup.h"

#include "AknFepUiInputStateCandidate.h"

#include "AknFepUiInputStateCandidateChinese.h"

#include "AknFepUiInputStatePredictiveCandidate.h"

#include "AknFepUiInputStatePredictiveInput.h"

#include "AknFepUiInputStatePredictiveInputChinese.h"

#include "AknFepUiInputStateInitialChineseGeneric.h"

#include "AknFepUiInputStateInitialLatinMultitap.h"

#include "AknFepUiInputStateInitialNumber.h"

#include "AknFepUiInputStateEntryPinyin.h"

#include "AknFepUiInputStateEntryZhuyin.h"

#include "AknFepUiInputStateInitialZhuyinFind.h"

#include "AknFepUiInputStateInitialStrokeFind.h"

#include "AknFepUiInputStateEntryStroke.h"

#include "AknFepUiInputStateInitialWesternPredictive.h"

#include "AknFepUiInputStateEntryWesternPredictive.h"

#include "AknFepUiInputStatePredictiveCandidatePinyin.h"

#include "AknFepUiInputStatePredictiveCandidateStroke.h"

#include "AknFepCaseManager.h"

#include "AknFepPanic.h"

#include "AknFepUiCtrlContainerChinese.h"				// phrase input container

#include "AknFepUiInputStateEntryPinyinPhrase.h"		// phrase pinyin entry state class

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

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

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

#include "aknfepuiinputstateentryzhuyinphrasecreation.h"     // zhuyin phrase creation

#include "AknFepUiInputStateEntryZhuyinPhrase.h"		// phrase zhuyin entry state class

#include "AknFepUiInputStateEntryStrokePhrase.h"		// phrase Stroke entry state class

#include "AknFepUiInputStateCandidateChinesePhrase.h"          // phrase candidate state class

#include "aknfepuictrleditpane.h"           //phrase EEP control

#include "AknFepUiInputStateCandidatePinyinAndStrokePhrase.h"

#include "AknFepUiInputStatePredictiveInputPhrase.h"

#include "AknFepUiInputStatePredictiveInputChinesePhrase.h"

// Qwerty input

#include "AknFepUiInputStateInitialChineseGenericQwerty.h"

#include "AknFepUiInputStateEntryQwertyPinyin.h"

#include "AknFepUiInputStateEntryQwertyStroke.h"

#include "AknFepUiInputStateEntryQwertyCangJie.h"

#include "AknFepUiInputStateEntryQwertyZhuyin.h"

#include "AknFepUiInputStateCandidateQwertyZhuyin.h"

#include "AknFepUiInputStatePredictiveCandidateQwertyZhuyin.h"

#include "AknFepUiInputStatePredictiveInputQwerty.h"

#include "AknFepUiInputStatePredictiveInputQwertyPinyin.h"

#include "AknFepUiInputStatePredictiveInputQwertyZhuyin.h"

#include "AknFepUiInputStatePredictiveCandidatePinyinPhrase.h"

#include "AknFepUiInputStatePredictiveCandidateStrokePhrase.h"

#include "AknFepUiInputStatePredictiveCandidatePhrase.h"

#include "AknFepUiInputStatePredictiveInputQwertyStroke.h"

// Qwerty phrase input

#include "AknFepUiInputStateEntryQwertyStrokePhrase.h"

#include "AknFepUiInputStateEntryQwertyPinyinPhrase.h"

#include "AknFepUiInputStatePredictiveInputQwertyChinesePhrase.h"

#include "AknFepUiInputStatePredictiveInputQwertyPinyinPhrase.h"

#include "AknFepUiInputStateEntryQwertyZhuyinPhrase.h"

#include "AknFepUiInputStateCandidateQwertyZhuyinPhrase.h"

#include "AknFepUiInputStatePredictiveCandidateQwertyZhuyinPhrase.h"

#include "AknFepUiInputStatePredictiveInputQwertyZhuyinPhrase.h"

#include "AknFepUiInputStatePredictiveInputQwertyStrokePhrase.h"

#ifdef RD_INTELLIGENT_TEXT_INPUT        

#include "AknFepUIInputStateEntryMiniQwertyPinyinPhrase.h"

#include "AknFepUiInputStateCandidateMiniQwertyPinyinAndStrokePhrase.h"

#include "AknFepUiInputStatePredictiveInputMiniQwertyChinesePhrase.h"

#include "AknFepUiInputStatePredictiveCandidateMiniQwertyChinesePhrase.h"

#include "AknFepUiInputStateEntryMiniQwertyZhuyinPhrase.h"

#include "AknFepUiInputStateCandidateMiniQwertyZhuyinPhrase.h"

#include "aknfepuiinputstateminiqwertyzhuyinphrase.h"//phrase creation for mini qwerty zhuyin

#include "aknfepuiinputstateminiqwertystrokephrase.h"

#include "AknFepUIInputStateEntryMiniQwertyCangJie.h"

#include "aknfepuiinputstateentryhalfqwertyphrase.h"

#include "AknFepUiInputStateCandidateHalfQwertyChinesePhrase.h"

#include "AknFepUiInputStateInitialChineseGenericHalfQwerty.h"

#include "AknFepUiInputStatePredictiveCandidateHalfQwertyChinesePhrase.h"

#endif

// Qwerty Chinese find

#include "AknFepUiInputStatelStrokeFindQwerty.h"

#include "AknFepUiInputStateZhuyinFindQwerty.h"

#include <AknIndicatorContainer.h>  

#include <PtiEngine.h> 

#include <PtiDefs.h>

#include <avkon.rsg>        //phrase creation

#include <AknFep.rsg>

// CONSTANTS

const TInt16 KStrokeHorizontalValue = 0x4e00; 

const TInt16 KStrokeVerticalValue = 0x4e28;

const TInt16 KStrokeDownToLeftValue = 0x4e3f;

const TInt16 KStrokeDownToRightValue = 0x4e36;

const TInt16 KStrokeBendingValue = 0x4e5b;

const TInt16 KStrokeQuestionValue = 0x003f;

const TInt16 KStrokeUnicode = 0x2461;

const TInt16 KZhuyinIndicator = 0x2462;

/**

*  CAknFepUIManagerChinese class.

* 

*/

//============================ MEMBER FUNCTIONS ==============================

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

// CAknFepUIManagerChinese::NewL

// 

// 

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

//

CAknFepUIManagerChinese* CAknFepUIManagerChinese::NewL(MAknFepManagerUIInterface* aFepMan, 

                                       CAknFepCaseManager* aCaseMan, TLanguage aLanguage)

    {   

    CAknFepUIManagerChinese* self = new(ELeave)CAknFepUIManagerChinese(aFepMan, aCaseMan);

    CleanupStack::PushL(self);

    self->ConstructL(aLanguage);

    CleanupStack::Pop();

    return self;

    }

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

// CAknFepUIManagerChinese::~CAknFepUIManagerChinese

// 

// 

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

//

CAknFepUIManagerChinese::~CAknFepUIManagerChinese()

    {

    delete iContainerPane;

    }

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

// CAknFepUIManagerChinese::HandleKeyL

// 

// 

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

//

TBool CAknFepUIManagerChinese::HandleKeyL(TInt aKey, TKeyPressLength aLength, TEventCode aEventCode)

    {

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT    

    // In the initial state, use the base implementation which support long

    // press number entry on QWERTY. In other states the long press is not

    // handled.

    if ( (aLength == EShortKeyPress && iFepUiState.State() == EInitial) ||

         (aLength == ELongKeyPress && iInitialFepUIState == EInitial) )

        {

        return CAknFepUIManagerBase::HandleKeyL( aKey, aLength );

        }

    else if ( iFepMan->EditorHasFreeSpace() )

        {

#endif // RD_INTELLIGENT_TEXT_INPUT

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

    TUIState currentState = iFepUiState.State();

    //when the state is EEntry and input mode is pinyin or zhuyin and akey = starkey

    //just handles EEventKey

    if( EPtiKeyStar == aKey && currentState == EEntry 

    		&& ( iFepMan->InputMode() == EPinyin || iFepMan->InputMode() == EZhuyin )

    		&& aEventCode != EEventKey )

    	{

    	return EFalse;

    	}

    if (aLength == EShortKeyPress)

        {

        iInitialFepUIState = currentState;

        }

    if(!iStatePtr->HandleKeyL(aKey, aLength))

        {

        if(currentState != iStatePtr->State()) //Check to see if we've changed state.

            {

            return iStatePtr->HandleKeyL(aKey, aLength);

            }

        return EFalse; // we've failed to handle it..

        }

    return ETrue; //we're ok.

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT

        }

    else

        {

        // FepManager must let some long press events to pass here even when

        // editor has no space, because long press may still work. But if

        // the long press was not handled, then the key event should not be

        // handled at all in this case.

        return EFalse;

        }

#endif // RD_INTELLIGENT_TEXT_INPUT

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__    

    }

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

// CAknFepUIManagerChinese::CloseUI

// 

// 

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

//

void CAknFepUIManagerChinese::CloseUI()

    {

    // update cba

    TRAP_IGNORE(FepMan()->UpdateCbaL(NULL));

    iContainerPane->EditPaneWindow()->SetCurrentCBAResID( 0 );

    if (iQwertyMode)

        {

#ifdef RD_INTELLIGENT_TEXT_INPUT 

        if ( EPtiKeyboardHalfQwerty == iPtiEngine->KeyboardType() )

            {

            ChangeState(EHalfQwerty);

            }

        else

#endif

            {

            ChangeState(EQwerty);

            }

        }

    else

        {

        ChangeState(EInitial);

        }

    if (iContainerPane)

        {

        iContainerPane->CandidatePane()->ResetCandidateState();

        iContainerPane->EditPaneWindow()->ResetAllArray();

        iContainerPane->Enable(EFalse);

        }

    }

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

// CAknFepUIManagerChinese::GetFormatOfFepInlineText

// 

// 

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

//

void CAknFepUIManagerChinese::GetFormatOfFepInlineText(TCharFormat& aFormat, 

         TInt& aNumberOfCharactersWithSameFormat, TInt aPositionOfCharacter) const

    {

    if (iPredictive && iFepUiState.State() == EEntry)   // EInitial???

        {

        aFormat.iFontPresentation.iUnderline = EUnderlineOn;

        if (iFepMan->IsFlagSet(CAknFepManager::EFlagNoMatches))

            {

            aFormat.iFontPresentation.iHighlightStyle = 

                                   TFontPresentation::EFontHighlightNoMatchesIndicator;

            }

        TCursorSelection uncommit = iFepMan->UncommittedText();

        if (uncommit.Length()-aPositionOfCharacter>0)                   

            {

            aNumberOfCharactersWithSameFormat=uncommit.Length() - aPositionOfCharacter;

            }

        }

    }

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

// CAknFepUIManagerChinese::SupportLanguage

// 

// 

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

//

TInt CAknFepUIManagerChinese::SupportLanguage(TInt aMode) const

    {

    TInt lang = iLanguage;

    switch (aMode)

        {

        case ELatin:

            {

            lang = ELangEnglish;

            }

            break;

        case ENumber:

        case EPinyin:

        case EStroke:

        case ECangJie:

        case EStrokeFind:

        case EZhuyin:

        case EZhuyinFind:

        default:

            break;

        }

    return lang;

    }

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

// CAknFepUIManagerChinese::SetEditorContext

// 

// 

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

//

void CAknFepUIManagerChinese::SetEditorContext(TInt aContext)

    {

    if(iContainerPane)

        {

        iContainerPane->SetIsShownWithPopupWindows(

            aContext == CAknIndicatorContainer::EQueryEditorIndicators);

        }

   }

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

// CAknFepUIManagerChinese::ChangeState

// 

// 

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

//

TUIState CAknFepUIManagerChinese::ChangeState(TUIState aState)

    {

    // ask pti engine if phrase input is supported

    if(iPrevMode != iMode)

        {

        iPrevMode = iMode;

        ResetFlags();

        }

    if(!IsFlagSet(EQueryPtiEngineAlready))  

        {

        QueryPtiEngine();

        }

    // distinguish if Qwerty input in editing window state

    if(aState == EQwerty)

        {

        iQwertyMode = ETrue;

        }

    else if(aState == EInitial)

        {

        iQwertyMode = EFalse;

        }

    if(iQwertyMode)

        {

        ChangeStateQwerty(aState);

        }

    else

        {

        ChangeStatetItut(aState);

        }

    iPtiEngine->SetObserver(&iFepUiState);

#ifdef _DEBUG

    RDebug::Print(_L("UI Manager: New State: %d"), iFepUiState.State());

#endif

    // cba update: when input window exists, softkeys are not shown.

    TRAPD(err, iStatePtr->InitializeStateL());

    if(err != KErrNone)

        {

#ifdef _DEBUG

    RDebug::Print(_L("UI Manager: Initial Error: Mode = %d, State = %d"), 

                    iMode, iStatePtr->State());

#endif

        }

    return iStatePtr->State();

    }

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

// CAknFepUIManagerChinese::IsValidChineseInputKey

// 

// 

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

//

TBool CAknFepUIManagerChinese::IsValidChineseInputKey(TInt aKey) const

    {

    // This doesn't include checking for the 'tone' key, which is different...

    TBool response = ETrue;

    switch(aKey)

        {

    case EPtiKey0:

        if(((iMode == EPinyin) && (!IsFlagSet(ESupportPinyinPhrase) || 

            !iContainerPane->IsEnabled())) ||

           ((iMode == EStroke) && (!IsFlagSet(ESupportStrokePhrase) || 

            !iContainerPane->IsEnabled()))  || (iMode == EStrokeFind)) 

            {

            response = EFalse;

            }

        break;

    case EPtiKey1:

        if((iMode == EPinyin)&& (!IsFlagSet(ESupportPinyinPhrase) || !iContainerPane->IsEnabled()))

            {

            response = EFalse;

            }

        break;

    case EPtiKey2: //fall through

    case EPtiKey3:

    case EPtiKey4:

    case EPtiKey5:

    case EPtiKey6:

        break;  //always valid

    case EPtiKey7: //fall through

    case EPtiKey8:

    case EPtiKey9:

        if((iMode == EStroke) || (iMode == EStrokeFind))

            response = EFalse;

        break;

    default:

        response = EFalse;

        break;

        }

    return response;

    }

#ifdef RD_INTELLIGENT_TEXT_INPUT

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

// CAknFepUIManagerChinese::IsKeyMappedStroke

// 

// 

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

//

TBool  CAknFepUIManagerChinese::IsKeyMappedStroke(TInt aKey) const

    {

    TBuf<KMaxName> lowerdata;   

    iPtiEngine->MappingDataForKey((TPtiKey)aKey, lowerdata, EPtiCaseLower);  

    TInt StrokeUnicodePosition =0;

    if(lowerdata.Length()>0)

        {

        for(TInt i=0;i<lowerdata.Length();i++)

            {

            if(lowerdata[i]==KStrokeUnicode)

                {

                StrokeUnicodePosition = i+1;

                break;

                }

            }

        }

    if(lowerdata.Length() > StrokeUnicodePosition)

        {

        if (lowerdata[StrokeUnicodePosition] == KStrokeHorizontalValue || 

                lowerdata[StrokeUnicodePosition] == KStrokeVerticalValue || 

                lowerdata[StrokeUnicodePosition] == KStrokeDownToLeftValue || 

                lowerdata[StrokeUnicodePosition] == KStrokeDownToRightValue || 

                lowerdata[StrokeUnicodePosition] == KStrokeBendingValue ||

                lowerdata[StrokeUnicodePosition] == KStrokeQuestionValue)

            {

            return ETrue;

            }

        }

    return EFalse;

    }

#endif

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

// CAknFepUIManagerChinese::IsValidChineseInputKeyQwerty

// 

// 

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

//

TBool CAknFepUIManagerChinese::IsValidChineseInputKeyQwerty(TInt aKey) const

    {

    TBool response = EFalse;

#ifdef RD_INTELLIGENT_TEXT_INPUT        

    TPtiKeyboardType keyboardType = iPtiEngine->KeyboardType();

#endif

    if(iMode == EPinyin)

        {

        if( (aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) ||

        	(aKey >= EPtiKeyQwerty1 && aKey <= EPtiKeyQwerty9) ||

            (IsFlagSet(ESupportPinyinPhrase) && aKey == EPtiKeyQwertyApostrophe 

             && State() != EInitial))

            {

            response = ETrue;

            }

#ifdef RD_INTELLIGENT_TEXT_INPUT          

        if ( State() == EInitial && EPtiKeyboardHalfQwerty == keyboardType &&

           ( aKey == EPtiKeyQwertyU || aKey == EPtiKeyQwertyI || aKey == EPtiKeyQwerty3 ))

            {

            response = EFalse;

            }

#endif

        }

    if(iMode == EStroke || iMode == EStrokeFind)

        {

#ifdef RD_INTELLIGENT_TEXT_INPUT        

        if(EPtiKeyboardQwerty4x10 == keyboardType ||EPtiKeyboardQwerty3x11 == keyboardType )

            {            

            if( IsKeyMappedStroke(aKey)|| EPtiKeyQwertySpace == aKey)

                {

                response = ETrue;

                if(aKey == EPtiKeyQwertySpace && (State() == EInitial || State() ==EPredictiveInput))

                    {

                    response = EFalse;

                    }

                }

            }

        else if( EPtiKeyboardHalfQwerty == keyboardType ||

           EPtiKeyboardCustomQwerty == keyboardType)

            {

            MPtiLanguage *lang = NULL;

            RArray < TPtiNumericKeyBinding > keybinding;

            TBool IsStrokeKey = EFalse;