/*
* 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 = EPtiKeyboardNone;
    if( iPtiEngine != NULL )        
        {
        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;
            if(iPtiEngine)
            { 
            	  lang = iPtiEngine->CurrentLanguage();
            }
            if( iPtiEngine && lang )
                {
                TRAP_IGNORE(iPtiEngine->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))
                        {
                           IsStrokeKey = ETrue;
                           break;              
                        }
                    }
                }
            keybinding.Reset();
            if(IsStrokeKey || (aKey == EPtiKeyQwertySpace))
                {
                if((aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) ||
                   (aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty6) ||		
                   (aKey == EPtiKeyQwertySpace))
                    {
                    response = ETrue;
                    if(aKey == EPtiKeyQwertySpace && 
                    	(State() == EInitial || State() ==EPredictiveInput))
                        {
                        response = EFalse;
                        }                  
                    }
                }               
            }
        else
            {
#endif
        switch(aKey)
            {
            case EPtiKeyQwertyQ:
            case EPtiKeyQwertyW:
            case EPtiKeyQwertyE:
            case EPtiKeyQwertyA:
            case EPtiKeyQwertyS:
            case EPtiKeyQwertyD:
            case EPtiKeyQwertyI:
            case EPtiKeyQwertyO:
            case EPtiKeyQwertyP:
            case EPtiKeyQwertyJ:
            case EPtiKeyQwertyK:
            case EPtiKeyQwertyL:
            case EPtiKeyQwertySpace:
                {
                response = ETrue;
                if(aKey == EPtiKeyQwertySpace && (State() == EInitial 
                || State() ==EPredictiveInput))
                    {
                    response = EFalse;
                    }
                }
                break;
            }
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
        }
#endif
    
    if(iMode == ECangJie)
        {
        if (aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ)
            {
            response = ETrue;
            }
        }
    
    if(iMode == EZhuyin || iMode == EZhuyinFind)
        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
        if(EPtiKeyboardQwerty4x10 == keyboardType ||
           EPtiKeyboardQwerty3x11 == keyboardType )
            {
            TBuf<KMaxName> lowerdata;
            iPtiEngine->MappingDataForKey((TPtiKey)aKey, lowerdata, EPtiCaseLower);
       //     TInt ZhuyinUnicodeCur =0;
            for(TInt i=0;i<lowerdata.Length();i++)
                {
                if(lowerdata[i]==KZhuyinIndicator)
                    {
                response = ETrue;
                }   
                }
            }
        else if( EPtiKeyboardCustomQwerty == keyboardType)        
            {
			if((aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ))
    			{
				response = ETrue;        
    			}       	
            }
        else if (  EPtiKeyboardHalfQwerty == keyboardType )
            {
            if((aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) || 
                    (aKey >= EPtiKey0 && aKey <= EPtiKey9) ||
                    aKey == EPtiKeyQwertySpace )
                {
                response = ETrue;        
                }  
            }
        else
            {
#endif
        if((aKey >= EPtiKeyQwertyA && aKey <= EPtiKeyQwertyZ) ||
            (aKey >= EPtiKeyQwerty0 && aKey <= EPtiKeyQwerty9)||
            (aKey == EPtiKeyQwertySemicolon) ||
            (aKey == EPtiKeyQwertyApostrophe) ||
            (aKey == EPtiKeyQwertyComma) ||
            (aKey == EPtiKeyQwertyFullstop) ||
            (aKey == EPtiKeyQwertySlash))
            {
            response = ETrue;        
            }
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
        }
#endif        
#ifdef RD_INTELLIGENT_TEXT_INPUT        
    
    if( iPtiEngine != NULL && EPtiKeyboardQwerty4x12 == iPtiEngine->KeyboardType())
        {
#endif
    if(iMode == EZhuyin && IsFlagSet(ESupportZhuyinPhrase) && aKey == EPtiKeyQwertyApostrophe)
        {
        response = ETrue;
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
        }
#endif
    return response;
    }

TBool CAknFepUIManagerChinese::IsQwertyZhuyinToneMarkKey(TInt aKey) const
    {
    // only return ETrue when qwerty and zhuyin symbol input supported for corresponding key
    TInt supportSCTToneMarks = EFalse;
    MPtiCoreInfo* ptiCoreInfo = iPtiEngine->CoreInfo(EPtiEngineZhuyin);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
    TPtiKeyboardType keyboardType = iPtiEngine->KeyboardType();
#endif

    if(ptiCoreInfo)
        {
        supportSCTToneMarks = ptiCoreInfo->CapsBits() & ESupportSCTToneMarks;
        }

    ptiCoreInfo = iPtiEngine->CoreInfo(EPtiEngineZhuyinByPhrase);
    if(ptiCoreInfo)    
        {
        supportSCTToneMarks = 
                    supportSCTToneMarks || (ptiCoreInfo->CapsBits() & ESupportSCTToneMarks);
        }

    if(iQwertyMode && (iMode == EZhuyin) && supportSCTToneMarks)
        {
#ifdef RD_INTELLIGENT_TEXT_INPUT 
        if( keyboardType == EPtiKeyboardQwerty4x12)
            {
#endif            
            if(aKey == EPtiKeyQwerty3 || aKey == EPtiKeyQwerty4 || aKey == EPtiKeyQwerty6 || aKey == EPtiKeyQwerty7)
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
#ifdef RD_INTELLIGENT_TEXT_INPUT 
            }
        else if( keyboardType == EPtiKeyboardQwerty4x10 || keyboardType == EPtiKeyboardQwerty3x11)
            {
            if(aKey == EPtiKeyQwertyE || aKey == EPtiKeyQwertyR || aKey == EPtiKeyQwertyY || aKey == EPtiKeyQwertyU)
                {
                return ETrue;
                }
            else
                {
                return EFalse;
                }
            }
#endif        
        }
    else 
        {
        return EFalse;
        }
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::GetLatestDeliberateSelection
// 
// 
// ---------------------------------------------------------------------------
//
TPtr CAknFepUIManagerChinese::GetLatestDeliberateSelection() const
    {
    // need to cast around constness, as this is a const get but needs to call Des which isn't const
    typedef TBufC<MAknFepUICtrlInputPane::EMaxInputCharsPinyinPopupNotIncludingToneMark> pinyinBuffer;
    pinyinBuffer* bufPtr = CONST_CAST(pinyinBuffer*, &iLatestDeliberateSelection);
    return TPtr(bufPtr->Des());
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::FepUIState
// 
// 
// ---------------------------------------------------------------------------
//
TAknFepInputStateBase* CAknFepUIManagerChinese::FepUIState()
    {
    return &iFepUiState;
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::UIContainer
// 
// 
// ---------------------------------------------------------------------------
//
MAknFepUICtrlContainerChinese* CAknFepUIManagerChinese::UIContainer() const
    {
    return iContainerPane;
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::IsValidShiftKeyPress
// 
// 
// ---------------------------------------------------------------------------
//
TBool CAknFepUIManagerChinese::IsValidShiftKeyPress() const
    {
    TUIState state = State();
    TInt mode = FepMan()->InputMode();
#ifdef RD_INTELLIGENT_TEXT_INPUT        
    TPtiKeyboardType kbdType = iFepMan->KeyboardLayout();
    if (EPtiKeyboardQwerty4x12 == kbdType)
        {
#endif
    if (mode == EPinyin || mode == EZhuyin || mode == EStroke || mode == ECangJie)
        {
        if (mode == EZhuyin && state == EPredictiveInput)
            {
            return EFalse;
            }
        if (mode == EZhuyin && state == EPredictiveCandidate)
            {
            return ETrue;
            }
        
        if (state == EEntry || state == ECandidate || state == EPredictiveCandidate)
            {
            return EFalse;
            }
        }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
        }
    else if(EPtiKeyboardQwerty4x10 == kbdType ||
            EPtiKeyboardQwerty3x11 == kbdType ||
            EPtiKeyboardHalfQwerty == kbdType ||
            EPtiKeyboardCustomQwerty == kbdType)
        {
    	if (mode == EPinyin || mode == EZhuyin || mode == EStroke || mode == ECangJie)
            {
            if ( state == EEntry || state == ECandidate || /*state == EPredictiveCandidate ||*/ 
                state == EPredictiveInput || state == EMiniQwertyEdit || 
                state == EZhuyinSpelling || state == EZhuyinCandidate )
                {
                return EFalse;
                }         
            }
        }
#endif    
    
    return ETrue;
    }

#ifdef RD_INTELLIGENT_TEXT_INPUT        
TBool CAknFepUIManagerChinese::IsValidFnKeyPress() const
    {
    TUIState uiState = State();
    TInt mode = FepMan()->InputMode();
    if (mode == EPinyin || mode == EZhuyin || mode == EStroke || mode == ECangJie)
        {
        //if (uiState == EPredictiveCandidate || uiState == ECandidate)
        if (uiState == EEntry || 
        	uiState == ECandidate ||
        	uiState == EPredictiveCandidate || 
            uiState == EPredictiveInput ||
            uiState == EMiniQwertyEdit || uiState == EZhuyinSpelling ||
            uiState == EZhuyinCandidate )
            {
            return EFalse;
            }         
        }
    							   
    return ETrue;
    }

TBool CAknFepUIManagerChinese::IsValidLongChrKeyPress() const
    {
    TUIState state = State();
    TInt mode = FepMan()->InputMode();
    if ( mode == EPinyin || mode == EZhuyin || mode == EStroke )
        {
        if ( state == EEntry || state == EPredictiveInput )
            {
            return EFalse;
            }
        }
    return ETrue;
    }

#endif

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::SetInputLanguageL
// 
// 
// ---------------------------------------------------------------------------
//
void CAknFepUIManagerChinese::SetInputLanguageL(TLanguage aLanguage)
    {
    iLanguage = aLanguage;
    CloseUI();
    }


// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::CAknFepUIManagerChinese
// 
// 
// ---------------------------------------------------------------------------
//
CAknFepUIManagerChinese::CAknFepUIManagerChinese(MAknFepManagerUIInterface* aFepMan, 
                                                 CAknFepCaseManager* aCaseMan)
    : CAknFepUIManagerBase(aFepMan, aCaseMan),
      iFepUiState(NULL, NULL),
      iPrevMode(ENumber),
      iQwertyMode(ETrue)
    {
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::ConstructL
// 
// 
// ---------------------------------------------------------------------------
//
void CAknFepUIManagerChinese::ConstructL(TLanguage aLanguage)
    {
    CAknFepUIManagerBase::ConstructL(aLanguage);
    iContainerPane = FepMan()->UiInterface()->NewAknFepUICtrlContainerChineseL();
    ResetFlags();  
    }

// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::QueryPtiEngine
// 
// 
// ---------------------------------------------------------------------------
//
void CAknFepUIManagerChinese::QueryPtiEngine(void)
    {
    MPtiLanguage* ptiLang = iPtiEngine->CurrentLanguage();

    // query ptiengine 
    if(ptiLang)
        {
        SetFlag(EQueryPtiEngineAlready);
        if(ptiLang->HasInputMode(EPtiEnginePinyinByPhrase))
            {
            SetFlag(ESupportPinyinPhrase);
            }
            
        if(ptiLang->HasInputMode(EPtiEngineZhuyinByPhrase))
            {
            SetFlag(ESupportZhuyinPhrase);
            }
            
        if (ptiLang->HasInputMode(EPtiEngineStrokeByPhrase))
            {
            SetFlag(ESupportStrokePhrase);
            }
        }
    }

void CAknFepUIManagerChinese::ChangeStatetItut(TUIState aState)
    {
    switch(aState)
        {
        case EInitial:
            {
            switch(iMode)
            {
            case EPinyin:
            case EZhuyin:
            case EStroke:
            case ECangJie: 
                iFepUiState = TAknFepInputStateInitialChineseGeneric(this, iContainerPane);
                break;
            case EZhuyinFind:
                iFepUiState = TAknFepInputStateInitialZhuyinFind(this, iContainerPane);
                break;
            case EStrokeFind:
                iFepUiState = TAknFepInputStateInitialStrokeFind(this, iContainerPane);
                break;
            case ELatin:
                {
                if (iPredictive)
                    {
                    iFepUiState = TAknFepInputStateInitialWesternPredictive(this);
                    }
                else
                    {
                    iFepUiState = TAknFepInputStateInitialLatinMultitap(this);
                    }
                }
                break;
            case ENumber:
                {
                // Map directly to the resources...
                iFepUiState = TAknFepInputStateInitialNumber(this);
                break;
                }
            default:
                AknFepPanic(EAknFepPanicBadInputState);
            }
            break;
            }
        case EEntry:
            {
            switch(iMode)
                {
                case EPinyin:
                    if(IsFlagSet(ESupportPinyinPhrase))
                        {
                        iFepUiState = TAknFepInputStateEntryPinyinPhrase(this,iContainerPane);
                        }
                    else 
                        {
                        iFepUiState = TAknFepInputStateEntryPinyin(this,iContainerPane);
                        }
                    break;
                case EZhuyin:
                    if(IsFlagSet(ESupportZhuyinPhrase))
                        {	
                        iFepUiState = TAknFepInputStateEntryZhuyinPhrase(this,iContainerPane);
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStateEntryZhuyin(this,iContainerPane);
                        }
                    break;
                case EStroke:
                    if (IsFlagSet(ESupportStrokePhrase))
                        {
                        iFepUiState = TAknFepInputStateEntryStrokePhrase(this,iContainerPane);
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStateEntryStroke(this,iContainerPane);
                        }
                    break;
                case ELatin:
                    iFepUiState = TAknFepInputStateEntryWesternPredictive(this);
                    break;
                default:
                    AknFepPanic(EAknFepPanicBadInputState);
                }
            }
            break;
        case ECandidate:
            {
            // modify for phrase creation
            FepMan()->EntryPhrase( ETrue );
            FepMan()->EnableKeyStar( EFalse );
            switch ( iMode )
                {
                case EPinyin:
                    {
                    if ( IsFlagSet( ESupportPinyinPhrase ) )
                        {
                        iFepUiState
                            = TAknFepUiInputStateCandidatePinyinAndStrokePhrase(
                                this, iContainerPane );
                        }
                    }
                    break;
                case EStroke:
                    {
                    if ( IsFlagSet( ESupportStrokePhrase ) )
                        {
                        iFepUiState
                            = TAknFepInputStateCandidateStrokePhrase(
                                this, iContainerPane );
                        }
                    }
                    break;
                case EZhuyin:
                    {
                    if ( IsFlagSet( ESupportZhuyinPhrase ) )
                        {
                        iFepUiState
                            = TAknFepInputStateCandidateChinesePhrase( this,
                                iContainerPane );
                        }
                    }
                    break;
                default:
                    {
                    iFepUiState = TAknFepInputStateCandidateChinese( this,
                        iContainerPane );
                    }
                }
            }
            break;
            
        case EPredictiveCandidate:
            {
            // add for phrase creation
            FepMan()->PhraseCreation( EFalse );
            FepMan()->PinyinPhraseCreation( EFalse );
            FepMan()->EntryPhrase( ETrue );
            FepMan()->EnableKeyStar( ETrue );
            TRAP_IGNORE( FepMan()->UpdateCbaL( R_AKNFEP_SOFTKEYS_PHRASE_CREATION_SELECT_CANCEL_SELECT ) );
            iContainerPane->PinyinPopupWindow()->ResetStrokeArray();
            switch(iMode)
                {
                case EPinyin:
                    if(IsFlagSet(ESupportPinyinPhrase))
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidatePinyinPhrase(
                                                                    this,iContainerPane);
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidatePinyin(
                                                             this,iContainerPane);     
                        }
                    break;
                case EStroke:
                    if (IsFlagSet(ESupportStrokePhrase))
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateStrokePhrase(
                                                                   this,iContainerPane);     
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateStroke(
                                                              this,iContainerPane);     
                        } 
                    break;
                case EZhuyin:
                        if(IsFlagSet(ESupportZhuyinPhrase))
                            {
                            iFepUiState = TAknFepInputStatePredictiveCandidateChinesePhrase(
                                                                        this,iContainerPane);
                            }
                        else
                            {
                            iFepUiState = TAknFepInputStatePredictiveCandidate(this,iContainerPane);
                            }
                    break;
                default:
                AknFepPanic(EAknFepPanicBadInputState);
                }
            }
            break;
        case EPredictiveInput:
            if((IsFlagSet(ESupportPinyinPhrase) || IsFlagSet(ESupportZhuyinPhrase) 
             || IsFlagSet(ESupportStrokePhrase)) 
               && (iMode != ECangJie))
                {
                iFepUiState = TAknFepInputStatePredictiveInputChinesePhrase(this, iContainerPane);
                }
            else
                {
                iFepUiState = TAknFepInputStatePredictiveInputChinese(this, iContainerPane);
                }
            break;
        // add for phrase creation
        case EStrokeSequenceEdit:
            if ( IsFlagSet( ESupportStrokePhrase ) && ( iMode != ECangJie ) )
                {
                FepMan()->EnableKeyStar( EFalse );
                iFepUiState = TAknFepInputStateEditStrokePhrase( this, iContainerPane ); 
                }
            break;
        // add for phrase creation
        case EKeySequenceEdit:
            if ( IsFlagSet( ESupportPinyinPhrase ) && ( iMode != ECangJie ) )
                {
                iFepUiState = TAknFepInputStateEntryPinyinPhraseCreation( this, iContainerPane );
                }
            break;
        // add for phrase creation
        case EZhuyinSequenceEdit:
            if ( IsFlagSet( ESupportZhuyinPhrase ) && ( iMode != ECangJie ) )
                {
                iFepUiState = TAknFepInputStateEntryZhuyinPhraseCreation( this, iContainerPane );
                }
            break;
        // add for phrase creation
        case ESpellingSelection:
            if ( IsFlagSet( ESupportPinyinPhrase ) && (iMode != ECangJie) )
                {
                FepMan()->EnableKeyStar( EFalse );
                iFepUiState = TAknFepInputStateSpellingPinyinPhraseCreation( this, iContainerPane );
                }
            break;
        // add for phrase creation
        case ECandidateSelection:
            if ( IsFlagSet (ESupportPinyinPhrase) && ( iMode != ECangJie ) )
                {
                FepMan()->EnableKeyStar( EFalse );
                iFepUiState = TAknFepInputStateCandidatePinyinPhraseCreation( this, iContainerPane );
                }
            break;
        default:
            AknFepPanic(EAknFepPanicBadInputState);
        }
    
    }
    
void CAknFepUIManagerChinese::ChangeStateQwerty(TUIState aState)
    {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
    TPtiKeyboardType kbdType = iFepMan->KeyboardLayout();    
#endif    
    switch(aState)
        {
        case EQwerty:
            if(iMode == EPinyin || iMode == EStroke || iMode == EZhuyin || iMode == ECangJie)
                {
                iFepUiState = TAknFepInputStateInitialChineseGenericQwerty(this, iMode);
                }
            else if(iMode == EStrokeFind)
                {
#ifdef RD_INTELLIGENT_TEXT_INPUT 
                if(EPtiKeyboardQwerty4x10 == kbdType ||
                   EPtiKeyboardQwerty3x11 == kbdType)
                    {
                    iFepUiState = TAknFepInputStateStrokeFindMiniQwerty(this,iMode);
                    }
                else
                    {
#endif //RD_INTELLIGENT_TEXT_INPUT                
                iFepUiState = TAknFepInputStateStrokeFindQwerty(this,iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT 
                    }
#endif                
                }
            else if(iMode == EZhuyinFind)
                {
#ifdef RD_INTELLIGENT_TEXT_INPUT 
                if(EPtiKeyboardQwerty4x10 == kbdType ||
                   EPtiKeyboardQwerty3x11 == kbdType)
                    {
                    iFepUiState = TAknFepInputStateZhuyinFindMiniQwerty(this,iMode);
                    }
                else
                    {
#endif //RD_INTELLIGENT_TEXT_INPUT                 
                iFepUiState = TAknFepInputStateZhuyinFindQwerty(this,iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT 
                    }
#endif  
                }
            break;
#ifdef RD_INTELLIGENT_TEXT_INPUT
#ifdef __HALF_QWERTY_KEYPAD
        case EHalfQwerty: 
            if (iMode == EPinyin || iMode == EStroke || iMode == EZhuyin)
                {
                iFepUiState = TAknFepInputStateInitialChineseGenericHalfQwerty(
                        this, iMode);
                }
            else if(iMode ==EStrokeFind)
                {
                iFepUiState = TAknFepInputStateStrokeFindHalfQwerty(this,
                                            iMode);
                }    
            else if(iMode ==EZhuyinFind)
                {
                iFepUiState = TAknFepInputStateZhuyinFindHalfQwerty(this,
                                                            iMode);
                }
            break;
#endif
#endif
        case EEntry:
            {
            switch(iMode)
                {
                case EZhuyin:
                    if(IsFlagSet(ESupportZhuyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)
                           {
                           iFepUiState = TAknFepInputStateEntryMiniQwertyZhuyinPhrase(this, iContainerPane); 
                           }
                        else if(EPtiKeyboardHalfQwerty == kbdType)
                           {
                           iFepUiState = TAknFepInputStateEntryHalfQwertyZhuyinPhrase(this, iContainerPane);
                           }
                        else
                           {
#endif
                        iFepUiState = TAknFepInputStateEntryQwertyZhuyinPhrase(this, 
                                                                               iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                           }   
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStateEntryQwertyZhuyin(this, iContainerPane);
                        }
                    
                    break;
                case EPinyin:
                    if(IsFlagSet(ESupportPinyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                            
                            { 
                            iFepUiState = TAknFepInputStateEntryMiniQwertyPinyinPhrase(this, iContainerPane);
                            }
                        else if (EPtiKeyboardHalfQwerty == kbdType)
                            {
                            iFepUiState = TAknFepInputStateEntryHalfQwertyPinyinPhrase(this, iContainerPane);
                            }
                        else
                            {
#endif
                        iFepUiState = TAknFepInputStateEntryQwertyPinyinPhrase(
                                                           this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                            }
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStateEntryQwertyPinyin(this, iContainerPane);
                        }
                    break;
                case EStroke:
                    if (IsFlagSet(ESupportStrokePhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                        	
                            {
                            iFepUiState = TAknFepInputStateEntryMiniQwertyStrokePhrase(
                                                                  this, iContainerPane);
                        	}
                        else if (EPtiKeyboardHalfQwerty == kbdType)
                            {
                            iFepUiState= TAknFepInputStateEntryHalfQwertyStrokePhrase(this, iContainerPane);
                            }
                        else
 	                       {
#endif
                        	iFepUiState = TAknFepInputStateEntryQwertyStrokePhrase(
                                                             this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
 	                       }	
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStateEntryQwertyStroke(this, iContainerPane);
                        }
                    break;
                case ECangJie:
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                        {
                        iFepUiState = TAknFepInputStateEntryMiniQwertyCangJie(this, iContainerPane);                    	
                    	}
                    else
                    	{
#endif
                    	iFepUiState = TAknFepInputStateEntryQwertyCangJie(this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                    	}
#endif
                    break;
                default:
                    AknFepPanic(EAknFepPanicBadInputState);
                }
            }
            break;
        case ECandidate:
            if(iMode == EZhuyin)
                {
                if(IsFlagSet(ESupportZhuyinPhrase))
                    {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                    	{
                    	iFepUiState = TAknFepUiInputStateCandidateMiniQwertyZhuyinPhrase(
                                                                  this, iContainerPane);
                    	}
#ifdef __HALF_QWERTY_KEYPAD
                        else if ( EPtiKeyboardHalfQwerty == kbdType )
                            {
                            iFepUiState = TAknFepUiInputStateCandidateHalfQwertyChinesePhrase(
                                                                                              this, iContainerPane);
                            }
#endif
                    else
         	            {
#endif
         	            iFepUiState = TAknFepInputStateCandidateQwertyZhuyinPhrase(
                                                            this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
         	            }	
#endif
                    }
                else
                    {
                    iFepUiState = TAknFepInputStateCandidateQwertyZhuyin(this, iContainerPane);
                    }
                }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
            else if(iMode == EPinyin)
                {
                if(IsFlagSet(ESupportPinyinPhrase))
                    {
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                        { 
                        iFepUiState = TAknFepUiInputStateCandidateMiniQwertyPinyinAndStrokePhrase(this, iContainerPane);
                        }
                        else if(EPtiKeyboardHalfQwerty == kbdType)
                        {
                        iFepUiState=TAknFepUiInputStateCandidateHalfQwertyChinesePhrase(
                                                                             this, iContainerPane);
                        }
                    }                 
                }
            else if(iMode == EStroke)
            	{
                 if (IsFlagSet(ESupportStrokePhrase))
                        {
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                        	{
                            iFepUiState = TAknFepUiInputStateCandidateMiniQwertyStrokePhrase(this, iContainerPane);
                            }
                        else if ( EPtiKeyboardHalfQwerty == kbdType )
                            {
                            iFepUiState=TAknFepUiInputStateCandidateHalfQwertyChinesePhrase( this, iContainerPane);
                            }
                       }
            	}
	        else if(iMode == ECangJie)
	        	{
                if ( EPtiKeyboardQwerty4x10 == kbdType ||
                     EPtiKeyboardQwerty3x11 == kbdType ||
                     EPtiKeyboardHalfQwerty == kbdType ||
                     EPtiKeyboardCustomQwerty == kbdType)                    	
                {
                iFepUiState = TAknFepUiInputStateCandidateMiniQwertyPinyinAndStrokePhrase(
                                                                     this, iContainerPane);
                }
	        	}
#endif      
            break;
        case EPredictiveCandidate:
            if(iMode == EZhuyin)
                {
                if(IsFlagSet(ESupportZhuyinPhrase))
                    {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                    if ( EPtiKeyboardQwerty4x10 == kbdType ||
                         EPtiKeyboardQwerty3x11 == kbdType ||
                         EPtiKeyboardCustomQwerty == kbdType)                    	
                        {
                    	iFepUiState = TAknFepInputStatePredictiveCandidateMiniQwertyChinesePhrase(
                                                                          this, iContainerPane);
                    	}
#ifdef __HALF_QWERTY_KEYPAD
                    else if( EPtiKeyboardHalfQwerty == kbdType )
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateHalfQwertyChinesePhrase(
                                                                           this, iContainerPane);
                        }
#endif
                    else
                    	{
#endif
                    	iFepUiState = TAknFepInputStatePredictiveCandidateQwertyZhuyinPhrase(
                                                                      this, iContainerPane);                    	
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        }	
#endif
                    }
                else
                    {
                    iFepUiState = TAknFepInputStatePredictiveCandidateQwertyZhuyin(
                                                              this, iContainerPane);
                    }
                
                }
#ifdef RD_INTELLIGENT_TEXT_INPUT        
            else if(iMode == EPinyin)
                {
                if(IsFlagSet(ESupportPinyinPhrase))
                    {
                    if ( EPtiKeyboardQwerty4x10 == kbdType ||
                         EPtiKeyboardQwerty3x11 == kbdType ||
                         EPtiKeyboardCustomQwerty == kbdType)                    	
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateMiniQwertyChinesePhrase(
                                                                             this, iContainerPane);
                        }
#ifdef __HALF_QWERTY_KEYPAD
                    else if( EPtiKeyboardHalfQwerty == kbdType )
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateHalfQwertyChinesePhrase(
                                                                           this, iContainerPane);
                        }
#endif
                    }                 
                }
           else if(iMode == EStroke)
            	{
                 if (IsFlagSet(ESupportStrokePhrase))
                        {
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                        	{
                            iFepUiState = 
                                   TAknFepInputStatePredictiveCandidateMiniQwertyChinesePhrase(
                                                                          this, iContainerPane);
                        	}
#ifdef __HALF_QWERTY_KEYPAD
                    else if( EPtiKeyboardHalfQwerty == kbdType )
                        {
                        iFepUiState = TAknFepInputStatePredictiveCandidateHalfQwertyChinesePhrase(
                                                                           this, iContainerPane);
                        }
#endif
                       }
	
            	}
            else if(iMode == ECangJie)
            	{

                if ( EPtiKeyboardQwerty4x10 == kbdType ||
                     EPtiKeyboardQwerty3x11 == kbdType ||
                     EPtiKeyboardHalfQwerty == kbdType ||
                     EPtiKeyboardCustomQwerty == kbdType)                    	
                 {
                 iFepUiState = TAknFepInputStatePredictiveCandidateMiniQwertyChinesePhrase(
                                                                       this, iContainerPane);
                 }

            	}
#endif
            break;
        case EPredictiveInput:
            {
            switch(iMode)
                {
                case EPinyin:
                    if(IsFlagSet(ESupportPinyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                            {
                            iFepUiState = TAknFepInputStatePredictiveInputMiniQwertyChinesePhrase/*TAknFepInputStatePredictiveInputQwertyPinyinPhrase*/(this, iContainerPane);
                            }
                        else
                            {
#endif
                            iFepUiState = TAknFepInputStatePredictiveInputQwertyPinyinPhrase(
                                                                        this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
							}
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStatePredictiveInputQwertyPinyin(
                                                              this, iContainerPane);
                        }
                    break;
                case EStroke:                
                    if(IsFlagSet(ESupportStrokePhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                      	   {
                           iFepUiState = TAknFepInputStatePredictiveInputMiniQwertyChinesePhrase(
                                                                             this, iContainerPane);
                       	   }
                        else
         	               {
#endif
         	               iFepUiState = TAknFepInputStatePredictiveInputQwertyStrokePhrase(
                                                                     this, iContainerPane);                        	
#ifdef RD_INTELLIGENT_TEXT_INPUT        
         	               }
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStatePredictiveInputQwertyStroke(
                                                              this, iContainerPane);
                        }
                    break;
                case ECangJie:
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                    if ( EPtiKeyboardQwerty4x10 == kbdType ||
                         EPtiKeyboardQwerty3x11 == kbdType ||
                         EPtiKeyboardHalfQwerty == kbdType ||
                         EPtiKeyboardCustomQwerty == kbdType)                    	
                        {
                        iFepUiState = TAknFepInputStatePredictiveInputMiniQwertyChinesePhrase(
                                                                          this,iContainerPane);

                        }
                    else 
                    	{
#endif
                    	iFepUiState = TAknFepInputStatePredictiveInputQwerty(this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                    	}    
#endif
                    break;
                case EZhuyin:
                    if(IsFlagSet(ESupportZhuyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                    	
                        	{
                            iFepUiState = TAknFepInputStatePredictiveInputMiniQwertyChinesePhrase/*TAknFepInputStatePredictiveInputQwertyPinyinPhrase*/(this, iContainerPane);
                        	}
                        else
                        	{
#endif
                        	iFepUiState = TAknFepInputStatePredictiveInputQwertyZhuyinPhrase(
                                                                       this, iContainerPane);
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        	}
#endif
                        }
                    else
                        {
                        iFepUiState = TAknFepInputStatePredictiveInputQwertyZhuyin(
                                                              this, iContainerPane);
                        }
                    break;  
                default:
                    AknFepPanic(EAknFepPanicBadInputState);
                }
            }
            break;
#ifdef RD_INTELLIGENT_TEXT_INPUT 
        case EMiniQwertyEdit:
            {
            switch(iMode)
                {
                case EZhuyin:
                    if(IsFlagSet(ESupportZhuyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)
                           {
                           iFepUiState = TAknFepInputStateEditingMiniQwertyZhuyinPhrase( this, iContainerPane );
                           }
#endif
                        }
                    break;
                case EPinyin:
                    if(IsFlagSet(ESupportPinyinPhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                            
                            { 
                            iFepUiState = 
                                TAknFepInputStateEditinigMiniQwertyPinyinPhrase( 
                                                             this,
                                                             iContainerPane );
                            }                            
#endif
                        }
                    break;
                case EStroke:
                    if (IsFlagSet(ESupportStrokePhrase))
                        {
#ifdef RD_INTELLIGENT_TEXT_INPUT        
                        if ( EPtiKeyboardQwerty4x10 == kbdType ||
                             EPtiKeyboardQwerty3x11 == kbdType ||
                             EPtiKeyboardHalfQwerty == kbdType ||
                             EPtiKeyboardCustomQwerty == kbdType)                           
                            {
                            iFepUiState = 
                                TAknFepInputStateEditingMiniQwertyStrokePhrase(
                                                              this, 
                                                              iContainerPane);
                            }
#endif
                        }
                    break;
                default:
                    break;
                }   
            }
            break;
        case EZhuyinSpelling:
            {
            iFepUiState = TAknFepInputStateSpellingMiniQwertyZhuyin( this, iContainerPane );
            }
            break;
        case EZhuyinCandidate:
            {
            iFepUiState = TAknFepInputStateCanindateSelectingMiniQwertyZhuyin( this, iContainerPane );
            }
            break;
#endif
        default:
            AknFepPanic(EAknFepPanicBadInputState);
    }
}
    
void CAknFepUIManagerChinese::UpdateCangJieState()
    {
    // Reset mode
    if (iMode == ECangJie)
        {
        ChangeStateQwerty( EQwerty );
        }
    }

TBool CAknFepUIManagerChinese::IsValidChineseSymbol(TInt aKey) const
	{
	TBool respond = EFalse;
	if((aKey >= EStdKeyComma && aKey <= EStdKeyNkpPlus)|| aKey == EPtiKeyStar )
		{
		respond = ETrue;
		}
	return respond;
	}
#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__
#ifdef RD_INTELLIGENT_TEXT_INPUT
// ---------------------------------------------------------------------------
// CAknFepUIManagerChinese::RollbackPreviousCharL
// 
// 
// ---------------------------------------------------------------------------
//
TBool CAknFepUIManagerChinese::RollbackPreviousCharL()
    {
    if ( iInputSeqLenDeltaWithLastKey > 0 )
        {
        HandleKeyL( EStdKeyBackspace, EShortKeyPress );
        return ETrue;
        }
    else
        {
        return CAknFepUIManagerBase::RollbackPreviousCharL();
        }
    }
#endif // RD_INTELLIGENT_TEXT_INPUT
#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__
// End of file
