FCL/sf/mw/inputmethods: comparison fep/aknfep/inc/AknFepManager.h

equal deleted inserted replaced

-:ebd48d2de13c
+:ecbabf52600f
+/*
+* Copyright (c) 2002-2004 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 CAknFepManager definition.
+*
+*/
+#ifndef __AKN_FEP_MANAGER_H__
+#define __AKN_FEP_MANAGER_H__
+#include "AknFepGlobalEnums.h"          //TKeyPressLength
+#include "AknFepManagerUIInterface.h"   //MAknFepManagerUIInterface
+#include "AknFepLanguageManager.h"      //CAknFepLanguageManager
+#include <gulicon.h>
+#include "aknfepuiinterface.h"
+#include "aknfepuimenus.h"
+#include <fepbase.h>                    //CCoeFep
+#include <coeinput.h>                   //TCoeInputCapabilities
+#include <fepitfr.h>                    //MFepInlineTextFormatRetriever
+#include <aknedstsobs.h>                //MAknEdStateObserver
+#include <uikon.hrh>                    //TAknEditorNumericKeymap
+#include <aknEditStateIndicator.h>      //TAknEditingState
+#include <frmtlay.h>
+#include <biditext.h>
+#include <PtiDefs.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <tagmalayoutandsource.h>
+#endif
+#include <aknextendedinputcapabilities.h>
+#ifdef RD_SCALABLE_UI_V2
+#include <peninputclient.h>
+#endif //#ifdef RD_SCALABLE_UI_V2
+#include <AknNullService.h>             // CAknNullService
+#include <AknServerApp.h>               // MAknServerAppExitObserver
+#include <aknfeppensupportinterface.h>
+#include "avkon.hrh"
+#ifdef RD_HINDI_PHONETIC_INPUT
+#include <PtiIndicDefs.h>
+#endif
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+// Predictive QWERTY (XT9) changes ---->
+class MAknFepUiWordPopupContent;
+#include "AknFepCandidatePopup.h"
+#include "AknFepCandidatePopupCallback.h"
+// Predictive QWERTY (XT9) changes <----
+#endif //RD_INTELLIGENT_TEXT_INPUT
+class CAknFepPluginManager;
+class CAknFepKeyCatcherInterface;
+class MAknFepManagerInterface;
+class CAknFepIndicator;
+class CAknEdwinState;
+class CPeriodic;
+class MAknEditingStateIndicator;
+class CAknFepCaseManager;
+class CAknFepHashKeyManager;
+class CAknKeySoundSystem;
+class CPtiEngine;
+class CAknFepSharedDataInterface;
+class CApaDocument; // User Dictionary
+class CAknFepInlineTextDecorator;
+class CTextView;
+class MPeninputServerEventHandler;
+class MAknFepDocumentNavigation;
+class CAknFepUIInterface;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+class CAknFepFnKeyManager;
+#endif
+//phrase creation
+class CZhuyinKeyHandler;
+class CAknFepZhuyinAnalyser;
+class CZhuyinAnalyserDbFeed;
+//User DB view
+class CAknFepUserdbDlg;
+class CAknFepThaiSCTSelector;
+class CAknNavigationDecorator;
+// This could be moved inside FepManager class?
+enum TWesternNaviEvent
+{
+ENullNaviEvent,
+ELeftNaviEvent,
+ERightNaviEvent,
+EBackspaceEvent,
+EUpNaviEvent,
+EDownNaviEvent
+};
+enum TSpecialTextField
+		{
+		/**
+		* Constraints
+		*/
+ESplAny,
+ESplMailAddr,
+ESplNumeric,
+ESplPhoneNumber,
+ESplUrl,
+ESplDecimal,
+/**
+* Modifiers
+*/
+ESplPassword=0x10000,
+ESplUneditable=0x20000,
+ESplSensitive=0x40000,
+ESplNonPredictive=0x80000,
+ESPlInitialCapsWord=0x100000,
+ESplInitialCapsWordSentence=0x200000,
+ESplConstraintMask=0xFFFF
+		};
+const TInt KChrKeyMultitapTimeout = 1000000;
+const TInt KFnKeyLongPressTimeout = 600000;
+/**
+* Translates ET9Eng language codes into localised descriptors and command Id's
+*/
+class TFepLanguageTranslation
+{
+public:
+void ReadFromResource(TResourceReader& aReader);
+public:
+TPtrC           iName;
+TInt            iLanguageId;
+TInt            iCommandId;
+};
+class CChrMultiTapTimer : public CTimer
+{
+public:
+static CChrMultiTapTimer* NewL(TCallBack aCallback);
+void After(TTimeIntervalMicroSeconds32 aInterval);
+private:
+CChrMultiTapTimer(TCallBack aCallback);
+void ConstructL();
+// from CActive
+virtual void RunL();
+private:
+TCallBack iCallback;
+};
+/**
+* The CCoeFep derived class of AknFep
+* Controls mode in the Fep. Handles all interaction with the editor
+* Creates and owns the UI Manger, the Key Catcher and the edit state indicators
+*/
+class CAknFepManager :
+public CCoeFep,
+public MAknFepManagerUIInterface,
+public MFepInlineTextFormatRetriever,
+public MFepPointerEventHandlerDuringInlineEdit,
+public MAknFepUiInterfaceMenuObserver,
+public MAknServerAppExitObserver,   //embedding
+private MAknEdStateObserver,
+#ifdef RD_SCALABLE_UI_V2
+public CAknExtendedInputCapabilities::MAknEventObserver,
+#endif
+private MFormCustomDraw
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+,public MAknFepCandidatePopupCallback // Predictive QWERTY (XT9) changes
+#endif //RD_INTELLIGENT_TEXT_INPUT
+{
+private:
+class TTextDirectionalInfo
+{
+public:
+enum TTextDirectionalStatus
+{
+EUnknown,
+ENotInDocument,
+ENoDirectionalChunks,
+ERightToLeft,
+ELeftToRight
+};
+enum TDirectionalBlockEnvironment
+{
+EUndefined,
+EInsideBlock,
+EAtRightEndOfLine,
+EAtLeftEndOfLine,
+EAtRightEndOfBlockFacingOppositeDirectionalBlock,
+EAtLeftEndOfBlockFacingOppositeDirectionalBlock,
+EAtRightEndOfBlockFacingSameDirectionBlock,
+EAtLeftEndOfBlockFacingSameDirectionBlock
+};
+public:
+// Constructor
+TTextDirectionalInfo();
+void SetDirectionFromChunk( const CTmTextLayout::TTmChunkDescription& aChunk);
+public:
+TTextDirectionalStatus iDirectionalStatus;
+TDirectionalBlockEnvironment iBlockEnvironment;
+};
+public:
+/**
+* values for the flags required to maintain the internal
+* state of the Fep Manager during operation
+*/
+enum
+{
+EFlagInsideMultitapInlineEditingTransaction     =0x00000001,
+EFlagLaunchEditMenu                             =0x00000002,
+EFlagLongShiftKeyPress                          =0x00000004,
+EFlagNoActionDuringShiftKeyPress                =0x00000008,
+EFlagShiftKeyDepressed                          =0x00000010,
+EFlagInsideInlineEditingTransaction             =0x00000020,
+EFlagPassNextKey                                =0x00000040,
+EFlagQwertyChrKeyDepressed                      =0x00000080,  // Not used. Qwerty mode is not supported.
+EFlagLineFeedCharacter                          =0x00000100,
+EFlagEditorFull                                 =0x00000200,
+EFlagNewSharedDataInputMode                     =0x00000400,
+EFlagNoActionDuringChrKeyPress                  =0x00000800,
+EFlagSupressAutoUpdateAtEditorStart             =0x00001000,
+EFlagNoMatches                                  =0x00002000,
+EFlagSuppressInputStateChange                   =0x00004000,
+EFlagCompoundWord                               =0x00008000,
+EFlagChangeInputMode                            =0x00010000,
+EFlagForegroundUIComponentVisible               =0x00020000,
+EFlagMenuPaneVisible                            =0x00040000,
+EFlagRemoveMatchesMenuItem                      =0x00080000,
+EFlagInlineEditInBackground                     =0x00100000,
+EFlagNewSharedDataInputLanguage                 =0x00200000,
+EFlagLastCharacterInEditor                      =0x00400000,
+EFlagSpaceCharacter                             =0x00800000,        // adding for japanese
+EFlagFullWidthSpaceCharacter                    =0x01000000,        // adding for japanese
+EFlagBidiCursorIsInitialized                    =0x02000000,
+EFlagCursorPointsRightToLeft                    =0x04000000,
+EFlagAtDirectionallyAmbiguousPoint              =0x08000000,
+EFlagCharacterAdded                             =0x10000000,
+EFlagNoInlineEditFormatting                     =0x20000000,  // Not really used yet!
+EFlagQwertyShiftMode                            =0x40000000,  // Not used. Qwerty mode is not supported.
+EFlagSupressAutoUpdate                          =0x80000000
+};
+enum
+	{
+		EExtendedFlagShortPressHashKey                    =0x00000001,
+	EExtendedFlagNoModeChange                         =0x00000002,
+	EExtendedFlagShiftReleasedOnPopup                 =0x00000004,
+	EExtendedFlagOkKeyPressOnCandidatePopup           =0x00000008,
+	/* Flag to take care of graceful exit for FEP launched dialog when the underneath editor is closed */
+EExtendedFlagEdwinEditorDestroyed                 =0x00000010,
+/* Flag to set decide when to set multiple observer for FEP. Set this flag whenever a FEP aware dialog is launched */
+EExtendedFlagFepAwareDialogLaunched               =0x00000020,
+/* Flag to specify that pointer event type EDrag has happened */
+EExtendedFlagPointerEventTypeEDrag                =0x00000040
+	};
+//public constants
+enum
+{
+ESingleCharacter                            =1,
+EMaximumFepWordLength                       =63
+};
+private:
+/**
+* private constants
+*/
+enum
+{
+EShiftKeyRepeatDelay                        =800000, // 0.8s
+EQueryBufferLength                          =63,
+EDefaultNumericCharMapResId                 =0,
+EDefaultSCTResourceId                       =-1,
+ENoCharacters                               =0,
+EAknFepUid                                  =0x100056de,
+EStarKeyUnicodeValue                        =0x2A,
+EHashKeyUnicodeValue                        =0x23,
+ELeftSoftkeyIndex                           =CAknFepUIInterface::ELeftSoftkeyIndex,
+ERightSoftkeyIndex                          =CAknFepUIInterface::ERightSoftkeyIndex,
+EMiddleSoftkeyIndex                         =CAknFepUIInterface::EMiddleSoftkeyIndex,
+EWordConcatenationTimeout                   =2000000, // 2.0s
+ELanguageArrayGranularity                   =20,
+EChrKeyRepeatDelay                          =1000000, // 1.0s
+EHalfQwertyChrKeyRepeatDelay                =600000   //0.6 secs from Default actions UI spec
+};
+enum TChineseFepCursorType
+{
+EActive,
+EPassive
+};
+public:
+	enum
+		{
+		ECcpuStateNone       = 0,
+		ECcpuStateStartCopy  = 0x01,
+		ECcpuStateCopy       = 0x02,
+		ECcpuStateStartCut   = 0x04,
+		ECcpuStateCut        = 0x08,
+		ECcpuStateButton     = 0x10,
+		ECcpuStatePosted               = 0x20,
+		ECcpuStateHashDown             = 0x40,
+		ECcpuStateSelectionEventPosted = 0x80,
+		ECcpuStateEdwinInSelectionMode = 0x100,
+		ECcpuStateIgnoreStarUp          = 0x200,
+		ECcpuSupressEditMenuFromShiftUp = 0x400,
+		ECcpuStateCbaSymbol             = 0x800,
+		ECcpuStateIgnoreNextFocusChange = 0x1000,
+		ECcpuStataCommitPredictiveWord  = 0x2000,
+		ECcpuStateIgnoreNextEdwinSyncEvent = 0x4000,
+		ECcpuStateLosingFocus			   = 0x8000,
+		ECcpuStateUncommitWhenFocused = 0x10000,
+ECcpuStateHashKeyDeleteDone = 0x20000,
+ECcpuStateSupressCursorMoveToEnd = 0x40000,
+ECcpuStateChangeToPredictionMode = 0x80000,
+		ECcpuStateNewPredictiveWord = 0x100000,
+		ECcpuStateShiftkeyWasPressedBeforeLosingFocus = 0x200000,
+		ECcpuStateCbaShown = 0x400000
+};
+	enum TShowSctMode
+	    {
+	    EShowSctFirst=0,
+	    EShowPctFirst,
+	    EShowSmileyFirst
+	    };
+private:
+	 // These are needed to remember editor's ccpu state
+	 // for editing options submenu.
+enum
+	{
+	ECcpuStatusFlagCanCopy  = 0x01,
+	ECcpuStatusFlagCanCut   = 0x02,
+	ECcpuStatusFlagCanPaste = 0x04,
+	};
+private:
+class TLanguageCapabilities
+{
+public:
+TInt iInputLanguageCode;        // Symbian language code.
+TBool iLocalInputLanguageInUse;
+TBool iArabicIndicDigitsAllowed;
+TBool iEasternArabicIndicDigitsAllowed;
+TBool iIndicDigitsAllowed;
+TDigitType iLocalDigitType;
+TDigitType iNumericEditorDigitType;
+TBool iSupportsCase;
+TBool iSupportsWesternPredictive;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+// Predictive QWERTY changes ---->
+TBool iSupportsWesternQwertyPredictive; // predicitve QWERTY
+// Predictive QWERTY changes <----
+#endif //RD_INTELLIGENT_TEXT_INPUT
+TBool iRightToLeftLanguage;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+#ifdef __HALF_QWERTY_KEYPAD
+TBool iSupportsWesternHalfQwertyPredictive;
+#endif //__HALF_QWERTY_KEYPAD
+#endif //RD_INTELLIGENT_TEXT_INPUT
+};
+public:
+/**
+* C++ Constructor
+*/
+CAknFepManager(CCoeEnv& aConeEnvironment);
+/**
+*  Second phase construction
+*/
+void ConstructL(const CCoeFepParameters& aFepParameters);
+/**
+* destructor
+*/
+virtual ~CAknFepManager();
+public: //from MAknFepManagerUIInterface
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+Returns the keyboard layout
+*/
+TPtiKeyboardType KeyboardLayout() const;
+/**
+Returns the current keyboard layout in use.
+*/
+CAknFepFnKeyManager::TFnKeyState FnKeyState();
+void SetFnKeyState(CAknFepFnKeyManager::TFnKeyState aState);
+/**
+* Returns the resource ID of the numeric editor in use
+*/
+TInt GetNumericSCTResID();
+#ifdef __REVERSE_FN_KEY_SUPPORTED
+/**
+Returns if the input is in reverse Fn key input mode.
+*/
+virtual TBool IsReverseFnkeyInput();
+void SetReverseFnkeyInputMode(TBool iIsOn);
+/**
+* Returns true if the aChar is allowed in the numeric editor
+*/
+TBool IsValidCharInNumericEditorL( TChar aChar ) const;
+/**
+* Filter the char for Fn reverse mode in case of
+* numeric editor. This function should call
+* in case of numeric editor reverse mapping.
+*/
+TBool IsValidCharForNumericInFnReverseL(TInt aKey, TPtiTextCase aCase) ;
+#endif //__REVERSE_FN_KEY_SUPPORTED
+virtual void AddOneSpaceOrMoveCursorL();
+#endif
+	virtual TBool IsAllowedKeymappingForNumberMode(TChar aChar) const;
+	/**
+* closes the UI
+* commits any character in multitap
+*/
+virtual TBool TryCloseUiL();
+/**
+* Used by the UI manager to inform the Fep Manager that the UI has activated.
+*/
+virtual void SendUIActivatedNotification();
+/**
+* Used by the UI manager to inform the Fep Manger that the UI has not activated.
+*/
+void SendUIDeActivatedNotification();
+/**
+* Plays sound
+*/
+virtual void PlaySound(TAvkonSystemSID aSound) const;
+/**
+* Set current long clear key press
+*/
+virtual void SetLongClearAfterCloseUI(TBool aLongClear);
+	/**
+	 * Align the Logical and Visual cursor positions.
+	 *
+* @since 3.2
+* @param aType Cursor type.
+* @param aToLeft ETrue if the position to the left is to be found,
+*			 	  EFalse if the position to the right is to be found.
+* @return None
+	 */
+	void AlignLogicalAndVisualCursorL( TTmDocPosSpec::TType aType, TBool aToLeft );
+	/**
+	 * This method removes the Repha character. The function goes to the
+	 * start of the syllable, checks if repha character is present and
+	 * removes it.
+	 *
+	 * @since 3.2
+	 * @param None.
+	 * @return None.
+	 */
+	void RemoveRephaCharacterL();
+	/**
+	 * Checks if the Repha character has been attached to the syllable
+	 *
+	 * @since 3.2
+	 * @param None.
+	 * @return ETrue if present else EFalse.
+	 */
+	TBool IsRephaPresent();
+	/**
+	 * Retrieve the Previous to previous character during multitapping.
+	 *
+	 * @since 3.2
+	 * @param aContextSensitive EFalse is the default parameter.
+	 *						    ETrue is used for requesting the function
+	 *						    to check for extraction of the character
+	 *						    two positions before the seleted text.
+	 *
+	 * @return The previous to previous character if any.
+	 */
+	TText PreviousToPreviousChar( TBool aContextSensitive = EFalse );
+	 /**
+	 * This method is called for removing the Rakar character. The function
+	 * checks if Rakar (Virama+Ra)  is present.
+	 *
+	 * @since 3.2
+	 * @param None.
+	 * @return None.
+	 */
+	void RemoveRakarCharacterL();
+/**
+	 * This method is called for removing the N characters from the
+	 * specified position. If the text to be removed is not yet
+	 * committed, it is updated with NULL descriptor and committed.
+	 *
+	 * @since 5.0
+	 * @param TInt aPos position to start searching from. By default
+	 *              Searching will start from the cursor position.
+	 * @param TInt aNumOfCharacters Number of characters to remove.
+	 * @param TBool Should cursor be positioned at the original location.
+	 * @return None.
+	 */
+void RemoveTextFromEditorL( TInt aNumOfCharacters, TInt aPos = 0,
+TBool aIsToAlignCursor = ETrue );
+	/**
+	 * Align the Logical and Visual cursor positions.
+	 * Overloaded method which uses FindDocPos
+	 *
+* @since 5.0
+* @param None
+* @return None
+	 */
+	void AlignLogicalAndVisualCursorL();
+	CAknFepPluginManager* PluginUIManager();
+//Phrase creation
+	MZhuyinKeyHandler* ZhuyinKeyHandler();
+	CAknFepZhuyinAnalyser* ZhuyinAnalyser();
+	void UpdateStickyState();
+#ifdef RD_MARATHI
+	/**
+	 * This function checks if the previous two characters are
+	 * the combination of Chandra-A
+	 *
+	 * @since 5.0
+	 * @param None
+	 * @return TBool.
+	 */
+	TBool IsChandraAPresentL();
+	/**
+	 * This function checks if the previous Chandra-A is present
+	 * before the cursor position
+	 *
+	 * @since 5.0
+	 * @param None
+	 * @return TBool.
+	 */
+	TBool IsEyeLashRaPresentL();
+#endif // RD_MARATHI
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+	 * This function returns the current case.
+	 * Required for Shift key handling.
+	 *
+	 * @since 3.2
+	 * @param None
+	 * @return TBool.
+	 */
+	TInt GetCurrentCase();
+	 /**
+	 * This function set the flag of chr composition key
+	 * in mini qwerty
+	 *
+	 * @since 3.2
+	 * @param aFlag ETrue if it is chr composition key.
+	 * @return None.
+	 */
+	void  SetComposChrFlag( TBool aFlag );
+	/**
+	 * This function get the flag of chr composition key
+	 * in mini qwerty
+	 *
+	 * @since 3.2
+	 * @param None.
+	 * @return ETrue if it is chr composition key..
+	 */
+	TBool GetComposChrFlag();
+	/**
+	 * Hides the exact word popup.
+	 */
+	void HideExactWordPopUp();
+	/**
+* @return   ETrue   If the exact word pop up is shown.
+*/
+	TBool IsExactWordPopUpShown();
+#endif
+#ifdef RD_HINDI_PHONETIC_INPUT
+//hindi_phonetic_fixes
+	/*
+* This functions toggles the case from upper to lower
+* @since 5.0
+* @param None
+* @return  void
+*/
+virtual void HandleIndicCaseL();
+#endif
+public: //interface to the key catcher
+/**
+* Handles key events passed from the Key Catcher, excluding the shift key event
+* which is dealt with separately in the HandleShiftKeyEventL function.
+* State will always be Intital or UIActive.
+*/
+TKeyResponse HandleKeyEventL(TUint aCode, TKeyPressLength aLength, TEventCode aEventCode = EEventKey);
+/**
+*  Shift keys are dealt with in a different way to other keys, the action is on the up
+*  key event.
+*/
+TKeyResponse HandleShiftKeyEventL(TEventCode aEventCode);
+/**
+*  Thai 0 key is handled differently. If 0 key is up before long keypress, we show SCT.
+*/
+TKeyResponse HandleThai0KeyEvent(TEventCode aEventCode, TKeyPressLength aLength,
+TBool& aThai0KeyHandling);
+/**
+*  Chr key handling
+*/
+TBool HandleQwertyChrKeyEventL( TEventCode aEventCode );
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+#ifdef __HALF_QWERTY_KEYPAD
+	/**
+	*	Chr Key handling in half qwerty
+	*/
+	TKeyResponse HandleChrKeyForHalfQwertyL( TEventCode aEventCode);
+#endif //__HALF_QWERTY_KEYPAD
+#endif //RD_INTELLIGENT_TEXT_INPUT
+/**
+*  Control key handling
+*/
+TKeyResponse HandleQwertyControlKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aEventCode);
+/**
+* Handles key events for qwerty input mode.
+*
+* @since 3.0
+* @param aKeyEvent An event to be handled.
+* @param aResponse Repsonse (consumed / not consumed) will be stored here.
+* @return ETrue if evenat was handled by this method.
+*         EFalse otrherwise.
+*/
+TBool HandleQwertyKeyEventL(const TKeyEvent& aKeyEvent, TKeyResponse& aResponse);
+	/**
+* Returns boolean value indicating whether it is ok to set edwin into "copy/paste"
+* mode.
+*
+* @since 3.1
+* @return ETrue if it is ok to editor into selectuion mode.
+*         EFalse otherwise.
+*/
+	TBool OkToActivateSelectionMode() const;
+/**
+* Returns the status of arabic-indic digit mode setting.
+*
+* @since 3.0
+*/
+TBool ArabicIndicDigitsInUse() const;
+	/**
+* Returns the status of Eastern arabic-indic digit mode setting.
+*
+* @since 3.0
+*/
+	TBool EasternArabicIndicDigitsInUse() const;
+	void NumberModeChangeGSNotification();
+	void DimInputmodeMenuItems(CAknFepUiInterfaceMenuPane* aMenuPane);
+	 /**
+* Dims the item corresponding to the mode aMode, in the edit mode menu
+*
+* @param aMenuPane the edit menu pane
+* @param aMode the mode to be dimmed
+*/
+void DimMenuItem(CAknFepUiInterfaceMenuPane* aMenuPane, TInt aMode);
+TInt FepShowVkbPreviewStatus();
+TInt PluginInputMode() const;
+private: // from CCoeFep
+/**
+* from CCoeFep - not used
+*/
+virtual void CancelTransaction();
+/**
+* from CCoeFep - not used
+*/
+virtual void IsOnHasChangedState();
+/**
+* from CCoeFep - not used
+*/
+virtual void OfferKeyEventL(TEventResponse& aEventResponse, const TKeyEvent& aKeyEvent,
+TEventCode aEventCode);
+/**
+* from CCoeFep - not used
+*/
+virtual void OfferPointerEventL(TEventResponse& aEventResponse,
+const TPointerEvent& aPointerEvent,
+const CCoeControl* aWindowOwningControl);
+/**
+* from CCoeFep - not used
+*/
+virtual void OfferPointerBufferReadyEventL(TEventResponse& aEventResponse,
+const CCoeControl* aWindowOwningControl);
+private:    // from MFepAttributeStorer (via CCoeFep)
+/**
+* from MFepAttributeStorer (via CCoeFep) - not used
+*/
+virtual TInt NumberOfAttributes() const;
+/**
+* from MFepAttributeStorer (via CCoeFep) - not used
+*/
+virtual TUid AttributeAtIndex(TInt aIndex) const;
+/**
+* from MFepAttributeStorer (via CCoeFep) - not used
+*/
+virtual void WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream) const;
+/**
+* from MFepAttributeStorer (via CCoeFep) - not used
+*/
+virtual void ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream);
+private:    // from MCoeForegroundObserver (via CCoeFep)
+/**
+* from MCoeForegroundObserver (via CCoeFep) - not used
+*/
+virtual void HandleGainingForeground();
+/**
+* from MCoeForegroundObserver (via CCoeFep) - not used
+*/
+virtual void HandleLosingForeground();
+private:        // from MCoeFocusObserver (via CCoeFep)
+virtual void HandleChangeInFocus();
+/**
+* in queries the editor is destroyed before the call to HandleChangeInFocus
+* so NULL the iInputCapabilities variables to prevent trying to save to an unreferenced object
+*/
+virtual void HandleDestructionOfFocusedItem();
+public: // from MAknEdStateObserver
+/**
+* from MAknEdStateObserver - not used
+*/
+virtual void HandleAknEdwinStateEventL(CAknEdwinState* aAknEdwinState,
+EAknEdwinStateEvent aEventType);
+private:    // from MEikCommandObserver (via MAknFepUiInterfaceMenuObserver)
+/**
+* from MEikCommandObserver
+* Processes user commands, in this case only commands from the edit menu
+*/
+virtual void ProcessCommandL(TInt aCommandId);
+/**
+* Constructs the component fully. This method is called when a
+* fep aware editor is first time focused for text input.
+*/
+void ConstructFullyL();
+/**
+* Deletes the objects constructed with ConstructFullyL() method.
+*/
+void CommonDestroyFep();
+private:    // from MAknFepUiInterfaceMenuObserver
+/*
+* not used as DynInitMenuPaneL() is now called before SetEmphasis() and HandleChangeInFocus()
+*/
+virtual void SetEmphasis(CBase* aMenuControl,TBool aEmphasis);
+/**
+* removes app menu panes and adds the FEP edit menu pane to the menu bar
+*/
+virtual void DynInitMenuBarL(TInt aResourceId,CAknFepUiInterfaceMenuBar* aMenuBar);
+/**
+* dynamically changes the edit menu depending on fep and editor state
+*/
+virtual void DynInitMenuPaneL(TInt aResourceId,CAknFepUiInterfaceMenuPane* aMenuPane);
+private:        //from MFepPointerEventHandlerDuringInlineEdit
+/**
+* from MFepPointerEventHandlerDuringInlineEdit - not needed, has to be implemented for MCoeFepAwareTextEditor interface
+* No pointer in Chinese Series 60
+*/
+virtual void HandlePointerEventInInlineTextL(TPointerEvent::TType aType, TUint aModifiers,
+TInt aPositionInInlineText);
+private:        //from MFepInlineTextFormatRetriever
+/**
+* from MFepInlineTextFormatRetriever - not needed, has to be implemented for MCoeFepAwareTextEditor interface
+*/
+virtual void GetFormatOfFepInlineText(TCharFormat& aFormat,
+TInt& aNumberOfCharactersWithSameFormat,
+TInt aPositionOfCharacter) const;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+// Predictive QWERTY changes (XT9) ---->
+public:
+	//from MAknFepCandidatePopupCallback ---->
+/**
+* Callback the get the current set of candidates
+* @param    aArray      An output parameter for the candidate strings
+* @param    aActiveIdx  An output parameter for the index of the
+*                       currently active candidate
+*/
+virtual void GetCandidatesL( CDesCArray& aArray, TInt& aActiveIdx );
+	/**
+	* Callback get new position for candidate list
+	* @param aRect  New rect position for candidate list.
+	*/
+virtual void GetUpdateCandidatePositionL(TRect& aRect);
+	//from MAknFepManagerUIInterfaceWestern ---->
+/**
+* Function to get the text direction for current language.
+* @return ETrue if language id RTL, EFalse if it is not
+*/
+TBool IsRightToLeftLanguage();
+TBool IsLanguageSupportPrediction();
+// Predictive QWERTY changes (XT9) <----
+#endif //RD_INTELLIGENT_TEXT_INPUT
+public:
+/**
+* Launches the mode selection menu
+*/
+void LaunchSelectModeMenuL();
+/**
+* Launches the edit word query in western predictive text mode
+*/
+void LaunchEditWordQueryL();
+	/**
+	* Returns the status of given extended input capability flag.
+	*/
+TUint ExtendedInputCapabilities() const;
+	/**
+	* Exit plugin itut spell mode by press ok btn
+	*/
+void ExitPluginSpellModeByOk();
+	/**
+	* Exit plugin itut spell mode by press cancel btn
+	*/
+void ExitPluginSpellModeByCancel();
+void SynCCPSoftKey();
+/**
+* checks that the editor the editor has free space to add another character
+* An editor of unlimited length will return its maximum size as zero
+*/
+TBool EditorHasFreeSpace( TInt aNumberOfCharacter = 0 ) const;
+		TBool IsSpecialNumericEditor();
+	void TryPopExactWordInICFL();
+/**
+* checks whether the current editor is a Java Secret editor.
+* return value: Etrue when it is a Java Secret editor.
+* Efalse when it is not.
+*/
+TBool IsJavaSecretEditor();
+	void HandleChangeInFocusForSettingFep();
+private:
+/**
+* Handles notifications that the UI has changed focus
+* <ul>
+* <\li>When moving away from a fep aware text editor saves the mode of the old editor
+* <\li>When moving to fep aware text editor gets the the mode if it has previously been saved
+* and checks if the editor supports secret text
+* <\ul>
+*/
+void HandleChangeInFocusL();
+/**
+* cleans up the fep after trapping a leave
+*/
+void CleanUpFep();
+/**
+*
+* @param aKeyCode the value of the key to simulate
+*/
+void SimulateKeyEventL(TUint aKeyCode, TBool aActiveObj=EFalse);
+/**
+* Tries to Reset the Shift Key Monitor
+* Cleans up FEP if failed
+*
+* @return KErrNone if succeed, KErrDied if failed
+*/
+static TInt ResetShiftKeyMonitorCallback(TAny* aObj);
+/**
+* Cancels the shift monitor
+* tells the editor to up date its cba
+* to enable copy/paste support on cba. We simulate via CCoeEnv
+* to avoid fep SimulateL adding shift modifiers
+*/
+void ResetShiftKeyMonitorL();
+/**
+* Cancels the shift key and concatenation timers if they are active
+*/
+void CancelAllTimerActivity();
+/**
+* checks whether a mode is permitted by the current editor
+*
+* @return ETrue is aMode is permitted, EFalse if it is not
+*/
+TBool IsModePermitted(TInt aMode, TWidthChar aWidth = ENoneWidthChar) const;
+/**
+*
+*
+* @return
+*/
+TUint EditorMode(TInt aMode, TWidthChar aWidth) const;
+/**
+* Synchronises the states of the Fep Manager and the Key Catcher
+*
+* @return System wide error code.
+*/
+TInt SyncStates(TAknFepManagerState aState);
+/**
+* Launches the matches popup list
+*/
+void LaunchMatchesPopupListL();
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+// Predictive QWERTY (XT9) changes ---->
+/**
+* Launches the compact match candidate list which follows the inline editor.
+* @param   aFocusedIndex   The index of the word focused by default.
+*                          If KErrNotFound is given, the currently active
+*                          word will be focused.
+*/
+void LaunchCandidatePopupListL( TInt aFocusedIndex = KErrNotFound );
+void StartInlineEditingWithSelectedWord(TDesC& aTextToUncommit);
+/**
+* Shows the exactly typed word above the inline editor if it differs from the
+* best guess word shown inline.
+*/
+void ShowExactWordPopupIfNecessaryL();
+/**
+* Launches the predictive setting dialog.
+*/
+void LaunchPredictiveSettingDialogL();
+#ifdef FF_DUAL_LANGUAGE_SUPPORT
+void  LaunchWritingLanguageSettingDialogL();
+void  LaunchDualLanguageSettingDialogL();
+#endif //FF_DUAL_LANGUAGE_SUPPORT
+// Predictive QWERTY (XT9) changes <----
+/**
+* Handle shift loop in chinese variant for half qwerty
+*/
+void HandleShiftHalfQwertyChineseL(TEventCode aEventCode);
+/**
+* Handle shift key loop in chinese variant for qwerty and mini qwerty
+*/
+void HandleShiftQwertyChineseL(TEventCode aEventCode);
+#endif //RD_INTELLIGENT_TEXT_INPUT
+void GetCandidatesWithIndexL(CDesCArray* aArray,
+						TInt& aActiveIdx, TInt& aSecondaryIdx);
+void TryPopExactWordInOtherPlaceL();
+/**
+* Launches the insert word query in western predictive text mode
+*/
+void LaunchInsertWordQueryL(const TDesC& aInitialText, TCursorSelection aTextSpanToReplace);
+/**
+* Actual query dialog for LaunchInsertWordQueryL and LaunchEditWordQueryL
+*/
+void LaunchFepQueryDialogL(TInt aResourceId, const TDesC& aInitialText,
+TCursorSelection aTextSpanToReplace);
+/**
+* Inserts a text directly into the editor which previously had focus
+*/
+void InsertTextFromDialogL(const TDesC& aTextFromDialog,
+TCursorSelection aExtentOfTextToReplace);
+/**
+* Launch the KutenCodeQuery
+*/
+void LaunchKutenCodeQueryL();
+/**
+* Returns the resource ID for the numeric mode special character map
+* available in the current editor.
+*/
+TInt NumericModeSCTResourceId() const;
+/**
+* Handles the hash key
+* <ul>
+* <\li>a short hash cycles through the modes
+* <\li>a long key press moves to number mode unless the mode is already number, in which case
+* it goes to default
+* <\ul>
+*/
+TKeyResponse HandleHashKeyL(TKeyPressLength aLength);
+/**
+*
+* @return Editor's numeric keymap for # and * keys of ITU-T mode.
+*/
+TInt EditorNumericKeymap() const;
+/**
+* dims the item on the edit menu corresponding to the current mode
+* the user can press cancel to remain in the same mode
+*
+* @param aMenuPane the edit menu pane
+*/
+void DimEditMenuModeItems(CAknFepUiInterfaceMenuPane* aMenuPane);
+/**
+* Launch confirmation note.
+*
+* @param aResourceId Confirmation note resource Id.
+*/
+void LaunchConfirmationNoteL(TInt aResourceId);
+/**
+* Enters a new character into the editing window
+* <p> Secret Text Editors do not use the MCoeFepAwareTextEditorInterface,
+* they interact with the editor by simlulating key events. When in Multitap, simultating a
+* numeric key event causes an extra key to be added to the control stack because the numeric
+* keys exist on the Series 60 keypad; the flag EFlagPassNextKey is used to ignore this.
+* <p> When secret editing in multitap, a backspace is simulated to replace the last
+* character in the editor.
+*/
+void NewCharacterL(const TDesC& aChar);
+/**
+* Enters a new phrase into the editing window
+*
+*/
+void NewTextL(const TDesC& aText);
+/**
+* Commits given string in the editing window. This function checks that
+* the editor has enough space to insert given string. If it not,
+* given string is cut, then it is committed.
+*/
+void CommitInlineEditL(const TDesC& aText, TInt aUncommitedTextChange);
+/**
+* Cansel inline input.
+*/
+void CancelInlineEdit();
+/**
+* Used by editing window when it draws inline input characters.
+*/
+void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine, TInt& aHeight,
+TInt& aAscent, TInt aDocumentOffset);
+/**
+* Used by Chinese UI to get cursor baseline position.
+*/
+void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine,TInt& aHeight,TInt& aAscent);
+/**
+* checks that the editor the editor has free space to add another character
+* An editor of unlimited length will return its maximum size as zero
+*/
+TBool IsEditorHasFreeSpace()const;
+/**
+* Returns the free space left in the Editor.
+*
+* @param aUnlimit.	Set to EFalse in case of Editors with limited text
+	 *				  	size
+	 *		  isToCountUncommittedTextLength. Pass ETrue if the lenght of
+	 *					Uncommitted text is to be counted.
+	 *
+	 * @return TInt. Free space left in the Editor.
+*/
+TInt EditorFreeSpace(TBool& aUnlimit,
+				TBool isToCountUncommittedTextLength = EFalse ) const;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+* Returns the free space left in the Editor. ITI Specific Implementation
+*
+* @param aUnlimit.	Set to EFalse in case of Editors with limited text
+	 *				  	size
+	 *		  isToCountUncommittedTextLength. Pass ETrue if the lenght of
+	 *					Uncommitted text is to be counted.
+	 *
+	 * @return TInt. Free space left in the Editor.
+*/
+	TInt EditorFreeSpaceForAutoWordCompletion(TBool& aUnlimit,
+TBool isToCountUncommittedTextLength = EFalse ) const;
+#endif
+#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+* Gives the amount of characters in the document.
+* @return   The number of characters in the active editor.
+*/
+TInt DocumentLength() const;
+/**
+* Tells if the given key event will replace the latest character in editor
+* because of multitapping or long press handling.
+*/
+TBool KeyEventWillReplaceCharacter( const TKeyEvent& aKeyEvent );
+#endif
+#endif
+/**
+* Uses TLocale to access the localized decimal separator in the kernel
+*/
+TChar CurrentDecimalSeparator() const;
+/**
+* Sets up the FEP state from the Editor State
+* Called by HandleChangeInFocusL()
+*/
+void ConfigureFEPFromEditorStateL();
+/**
+* Sets up the FEP State(character width) from the Editor Mode
+* @return FepMode
+*/
+TInt ConfigureFepModeFromEditorMode(TInt aEditorMode);
+/**
+* launch query which contains instructions on how to enter
+* chinese text using the FEP
+*/
+void LaunchHelpTextQueryL();
+/**
+* ensure that the UI is aware of the current editor context
+*/
+void UpdateEditorContext() const;
+/**
+* query whether the text is valid in the current editor
+*/
+TBool TextIsValidInEditor(const TDesC& aText);
+/**
+* Sets the style of the cursor to aType
+*/
+void SetCursorType(TChineseFepCursorType aType);
+/**
+* Returns the current editing state indicator
+*/
+MAknEditingStateIndicator* EditingStateIndicator() const;
+/**
+* Adds space at the end of the buffer if the feature is enabled.
+*/
+TBool TryHandleArrowRightEventL(TInt aDocumentLength);
+/**
+* Remove spaces from the end of the buffer if the cursor
+* is in last position. Only in Japanese variant.
+* Opposite functionality of TryHandleArrowRightEventL().
+*/
+TBool TryHandleArrowLeftEventL(TInt aDocumentLength);
+/**
+* Adds enter to the buffer if the cursor is at the end of the buffer and
+* feature KAknFepEnterWithScrollDown is enabled.
+*
+* @since 2.6
+* @param aDocumentLength Editor's document length
+* @return Boolean if the down key event was handled.
+*/
+TBool TryHandleArrowDownEventL(TInt aDocumentLength);
+inline void ResetFlags();
+/**
+* Handle the Chr Key Monitor
+* for Japanese variant only.
+*
+* @since 3.0
+* @return KErrNone if succeed, KErrDied if failed
+*/
+static TInt HandleChrKeyMonitorCallback(TAny* aObj);
+	/**
+	 * Enters a new ligature into the editing window.
+	 *
+* @since 3.2
+* @param aText Unicode value of the ligature.
+* @return None
+	 */
+	void NewLigatureL( const TDesC& aText );
+/**
+* Sets the current state to aState based on the input mode
+* used to show the indicator
+* @since 3.2
+*/
+void SetPredictiveIndicatorState(TAknEditingState& aState);
+static TInt HandleResourceChangedCallback(TAny* aObj);
+void ResourceChangedTimeroutL();
+/**
+* Exit plugin itut spell mode by press ok btn
+*/
+void ExitPluginSpellModeByOkL();
+#ifdef RD_SCALABLE_UI_V2
+	/**
+* Unregisters Fep as observer
+*/
+void UnregisterObserver();
+/**
+* Unregisters Fep as observer
+*/
+void RegisterObserver();
+#endif // RD_SCALABLE_UI_V2
+private:
+TUint EditorModeFromFepMode(TInt aFepMode);
+// returns sound system
+CAknKeySoundSystem* SoundSystem() const;
+void SetHashKeyStyle();
+void ReadHashKeyLoopL();
+TBool IsValidInLineCharacter(TChar aCharacter) const;
+TBool HandleLoopingInNaviEventL(TWesternNaviEvent aNaviEvent);
+static TInt WordConcatenationTimerTimeoutCallback(TAny* aObj);
+void WordConcatenationTimerTimeoutL();
+	void AddInputLanguageItemL(CAknFepUiInterfaceMenuPane* aMenuPane, TInt aIndex);
+	void SetQwertyModeToInputcapbility();
+	void SetExtendedInputCapabilities( TUint aCapabilities);
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+// Predictive QWERTY (XT9) changes ---->
+/**
+* Adds the "Input Options" option and its sub menu to the given menu.
+* @param    aMenuPane   The menu where the option should be added.
+* @param    aIndex      The location in the menu where the option should be added.
+*/
+void AddPredictiveModeOptionsL(CAknFepUiInterfaceMenuPane* aMenuPane, TInt aIndex) const;
+/**
+* Adds the XT9 Edit menu options to the given menu.
+* @param    aMenuPane   The menu where the option should be added.
+* @param    aIndex      The location in the menu where the option should be added.
+*/
+void AddPredictiveModeEditMenuL(CAknFepUiInterfaceMenuPane* aMenuPane, TInt aIndex) const;
+// Predictive QWERTY (XT9) changes <----
+#endif //RD_INTELLIGENT_TEXT_INPUT
+/* Sets default number mode when arabic language is used.
+* @param aMode either Latin or Arabic
+* @param aNbrModeType number mode type from GSLangPlugin.hrh
+*/
+void SetDefaultNumberMode( TInt aMode, TInt aNbrModeType );
+/**
+* Loads an icon from avkon bitmap file.
+* @param aIcons The array into which the icon will be added. Icons will be
+*        owned by this array.
+* @param aBitmapId ID of the actual bitmap.
+* @param aMaskId ID of the mask.
+*/
+void LoadIconL( CArrayPtr<CGulIcon>* aIcons, TInt aBitmapId, TInt aMaskId );
+/**
+* Add a menu item for User DB management.
+* phrase creation
+* @since S60 5.0 S60_version
+* @param aMenuPane The menu into which the mune item will be added.
+* @param aIndex Index of the menu item to insert.
+* @return none
+*/
+void AddUserDBDlgItemL( CAknFepUiInterfaceMenuPane* aMenuPane, TInt aIndex );
+/**
+* Return wether ipnut mode is change by press shift+space.
+* This is for half-qwerty.
+* @return ETure is change by press shift+space, otherwise EFalse.
+*/
+TBool IsChangeModeByShiftAndSpace();
+/**
+* Set wether ipnut mode is change by press shift+space.
+* This is for half-qwerty.
+* @return none
+*/
+void SetChangeModeByShiftAndSpace( TBool aFlag );
+/**
+* Handle the Fn Key Monitor
+*
+* @since 3.0
+* @return KErrNone if succeed, KErrDied if failed
+*/
+static TInt HandleFnKeyPressMonitorCallback(TAny* aObj);
+/**
+* Handle the Fn Key Monitor
+* for Qwerty only.
+*
+* @since 3.0
+*/
+void HandleFnKeyPressMonitor();
+/**
+* Activate fn key press monitor to detect long pressing event
+*/
+void ActivateFnkeyPressMonitor();
+/**
+* Deactivate fn key press monitor
+*/
+void DeactivateFnkeyPressMonitor();
+public:
+//Hash Key Manager Interface
+TBool IsOnlyNumericPermitted() const;
+void TryIncrementModeL(TInt aCurrentMode);
+void TryIncrementModeChineseQwertyL(TInt aCurrentMode);
+void TryIncrementChineseModeForQwertyL(TInt aCurrentMode);
+void TryChangeToSharedDataModeL();
+void TryChangeToModeBeforeL();
+TBool TryChangeModeL(TInt aMode);
+void ChangeInputLanguageL(TInt aInputLanguage);
+void RemovePreviousCharacterL();
+void  TryChangePredictiveInputModeL(TBool aFlag);
+/**
+* To Handle Indic Hash key
+*
+*
+* @since 3.2
+* @return the language id of the Input Language as in Cenral Repository (General Settings)
+*/
+TLanguage GetInputLanguageFromSharedDataInterface();
+/**
+* To Handle Hash key
+*
+*
+* @since 3.2
+* @return ETrue if the Last Key press was Hash key.
+*/
+TBool WasLastKeyPressAHashKey();
+/**
+* To Handle Hash key
+* To set or Reset the status maintained to know if last key pressed was Hash Key
+*
+* @since 3.2
+* @return nothin
+*/
+	void SetLastPressedHashKeyStatus(TBool aStatus);
+//Case Manager Interface
+MCoeFepAwareTextEditor* FepAwareTextEditor() const;
+TBool IsFepAwareTextEditor() const;
+TCursorSelection UncommittedText() const;
+void SetCase(TCase aCase);
+//made public for western
+/**
+* Retreives the State of the current editor
+*
+* @return the current editors state object
+*/
+CAknEdwinState* EditorState() const;
+/**
+* update the edit indicators when moving into a new input mode
+*/
+void UpdateIndicators();
+/**
+* Checks if the editor is in a state where a Special Character Table can be launched
+*/
+TBool IsAbleToLaunchSCT() const;
+/**
+* Get SCT Chars' Length to judge it's null
+*/
+TBool GetSctLengthL(TInt resourceId)const;
+/**
+* Get current editor's SCT resource id
+*/
+TInt GetCurrentEditorSCTResId() const;
+/**
+* Launch the Special Character Table
+*/
+void LaunchSpecialCharacterTableL(TInt aResourceId = EDefaultNumericCharMapResId,
+TBool aLaunchedByTouchWin=EFalse,
+TBool aSmileyFirst=EFalse);
+/**
+* Checks if the editor is in a state where a Pictograph Character Table can be launched
+*/
+TBool IsAbleToLaunchPCT() const;
+/**
+* Checks if the editor is in a state where a Pictograph Character Table can be launched
+*/
+TBool IsAbleToLaunchSmiley() const;
+/**
+* Launch the Pictograph Character Table
+*/
+void LaunchPictographCharacterTableL();
+//MAknFepManagerUIInterfaceWestern
+virtual void UpdateInlineEditL(const TDesC& aNewInlineText,
+TInt aPositionOfInsertionPointInInlineText);
+virtual void StartInlineEditL();
+virtual void StartInlineEditL(const TDesC& aText);
+virtual void StartInlineEditL(TCursorSelection aCursorSelection,
+const TDesC& aInitialInlineText,
+TInt aPositionOfInsertionPointInInlineText,
+TBool aCursorVisibility);
+virtual TBool CloseUiIfWordDeletedL();
+virtual TBool TryGetTextToUncommitL(TDes& aText, TInt aCode, TBool& aComsumeKey);
+/**
+* Addition for ITI features on FSQ.
+* To check which characters will be underlined.
+*/
+TBool TryGetTextToUncommitL(TDes& aText, TBool& aComsumeKey);
+virtual void UpdateCbaL(TInt aResourceId);
+virtual TBool TryRemoveNoMatchesIndicatorL();
+virtual TBool IsMoreGoodWordsComing(TInt aNewWordLength) const;
+#ifndef RD_INTELLIGENT_TEXT_INPUT
+virtual TBool IsMoreGoodAutoCompleteWordsComing(TInt aInputMode, TInt aPreviousWordLengh,
+TInt aNewWordLength) const;
+#endif //RD_INTELLIGENT_TEXT_INPUT
+virtual void TryStartCompoundWord();
+virtual void AddCompoundWordToUdbL();
+//MAknFepManagerUIInterfaceWestern made public for western
+inline TBool IsFlagSet(TInt aFlag) const;
+inline void SetFlag(TInt aFlag);
+inline void ClearFlag(TInt aFlag);
+inline TBool IsExtendedFlagSet(TInt aExtendedFlag) const;
+inline void SetExtendedFlag(TInt aExtendedFlag);
+inline void ClearExtendedFlag(TInt aExtendedFlag);
+inline void ResetExtendedFlags();
+inline TCoeInputCapabilities& InputCapabilities();
+void SetWesternPredictive( const TBool aWesternPredictive );
+void SetWesternAutoComplete( const TBool aWesternAutoComplete );
+void SetJapanesePredictive(const TBool aJapanesePredictive);
+void SetQwertyMode(const TBool aQwertyMode); // Empty implementation. Qwerty mode is not supported.
+TBool WesternPredictive(TInt aMode = 0) const;
+TBool IsPredictive(TInt aMode = 0) const;
+TBool Japanese() const;
+TBool IsOnlyFullWidthCharacterPermitted() const;
+TBool IsOnlyHalfWidthCharacterPermitted() const;
+TBool IsHalfAndFullKatakanaPermitted() const;
+TBool IsHalfAndFullLatinPermitted() const;
+TBool IsHalfAndFullNumberPermitted() const;
+virtual TWidthChar CharacterWidth() const;
+virtual CPtiEngine* PtiEngine() const;
+virtual void SetInlineEditingCursorVisibilityL(TBool aCursorVisibility);
+TInt  InputMode() const;
+TInt CangJieMode() const;
+TBool InputLanguageSupportsCaseChanges() const;
+/**
+* Queries supportting of KAknFepScrollLatinPredictive feature
+*
+* @since 2.6
+* @return ETrue if ScrollLatinPredictive was supported
+*/
+TBool IsAbleScrollLatinPredictive() const;
+/**
+* Previous case is returned.
+*
+* @since 2.6
+* @return TInt  EAknEditorTextCase or EAknEditorUpperCase or EAknEditorLowerCase
+*               If case cannot be saved, 0 value is returned.
+*/
+inline TInt CaseBefore() const;
+/**
+* @return true if current input language is one of Chinese input languages.
+*/
+inline TBool IsChineseInputLanguage() const;
+/**
+* @return true if current input language is arabic input languages.
+*/
+inline TBool IsArabicInputLanguage() const;
+/**
+* @return true if current input language is Korean input language.
+*/
+inline TBool IsKoreanInputLanguage() const;
+/**
+* Check Qwerty keypad
+*
+* @since 3.0
+* @return ETrue is Qwerty
+*/
+inline TBool IsQwerty() const;
+/**
+* Returns boolean value indicating whether hash key is in selection mode or
+* in traditional mode.
+*
+* @since 3.1
+* @return  ETrue if hash key is in text selection mode.
+*          EFalse otherwise.
+*/
+TBool HashKeySelectionInUse() const;
+/**
+* Returns the UI interface implementation used in the current app.
+*
+* @since 3.2
+* @return  The UI interface object used in the current app.
+*/
+CAknFepUIInterface* UiInterface();
+/**
+* Returns boolean value indicating whether edit submenu functionality is in use.
+*
+* @since 3.1
+* @return  ETrue if edit submenu functionality is in use.
+*          EFalse otherwise.
+*/
+TBool EditSubmenuInUse() const;
+/**
+* Set MultiTap Timer
+*
+* @since 3.0
+* @param aMultiTapTimer value of KAknFepMultiTapTimer setting
+*/
+void SetMultiTapTimer(const TInt aMultiTapTimer);
+/**
+* Set Japanese Qwerty Flags
+*
+* @since 3.0
+* @param aJapaneseQwertyFlags value of KAknFepJapaneseSpecialCharFlag setting
+*/
+void SetJapaneseQwertyFlags(const TInt aJapaneseQwertyFlags);
+	/**
+	* Calling this method will raise a flag which will cause predictive
+	* word to be commited during next call to TryCloseUiL-method. This
+	* is needed because of Japanese ReadingTextL.
+	*
+	* @since 3.1
+	*/
+	void SetDelayedCommit();
+/**
+* from MAknFepManagerUIInterface
+* query whether the special char is valid in the current editor
+*
+* @param aChar Checking a chracter
+*/
+TBool CharIsValidInEditor(TChar aChar);
+/**
+* from MAknFepManagerUIInterface
+* Returns the status of predictive input.
+*
+* @since 3.2
+* @return ETrue is available predictive input.
+*/
+TBool IsAbleToChangePrediction() const;
+/**
+* Commits uncommitted text in the editing window. For secret text editors,
+* only inline editing flags are changed
+*/
+void CommitInlineEditL();
+TBool GetIndicatorImgID(TInt& aIndicatorImgID, TInt& aIndicatorTextID);
+TInt CurrentInputLangCode();
+inline TFepSymbolOfHardwareOne SymbolInfoOfHardKey1();
+public:
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/*
+Sets the keyboard layout.
+**/
+void SetKeyboardLayout(TPtiKeyboardType aType);
+#endif
+virtual TText PreviousChar( TBool aContextSensitive = EFalse );
+virtual TText NextChar();
+virtual TBool IsZWSCharacterPresent( TBool aLigaturePresent = EFalse );
+void RemoveZWSCharacterL( TBool aIsViramaInputted,
+TBool aIsInMultitappingHalant = EFalse,
+TBool aIsCharModifier = EFalse,
+TBool aIsLigaturePresent = EFalse );
+void NewCharacterSequenceL(const TDesC& aText, TIndicInputResponse aResponse);
+TBool IsValidInlineIndicCharacter(TChar aCharacter) const;
+#ifdef RD_HINDI_PHONETIC_INPUT
+TBool IsIndicPhoneticInputLanguage() const;
+TInt SetPhoneticIndicator(TLanguage aInputLanguage);
+void TryChangePhoneticModeL();
+#endif
+TDigitType LocalDigit();
+public:
+/**
+* Auto word Completion is Enabled
+*
+* @since 3.2
+*/
+void SetAutoCompletionState(TInt aValue);
+#ifndef RD_INTELLIGENT_TEXT_INPUT
+void RemoveSuggestedCompletionL();
+#endif	//RD_PRED_AW_COMPLETION
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+TBool IsFnKeyMappedL(TPtiKeyboardType aKeyboardType = EPtiKeyboardNone);
+TBool IsFnKeyMapped();
+void SetFnKeyMappingState();
+TBool KeyMapsDifferentCharacterWithFn( TPtiKey aKey ) const;
+/**
+	 * Setter for the advanced predictive typing correction.
+	 * @param    aLevel   The level to be set.
+	 */
+	 void SetTypingCorrectionLevel(TInt aLevel);
+	 /**
+	 * Resetter for the advanced predictive Number Candidate setting.
+	 * @param    aValue   The value to be set.
+	 */
+	 void SetNumberCandidateState(TInt aValue);
+	 /**
+	* Setes the primary candidate from GS to the local state
+	*/
+	 void SetPrimaryCandidate(TInt aValue);
+#endif
+void SetStopProcessFocus(TBool aStop, TBool aClose = ETrue);
+TBool StopProcessFocus();
+TBool CloseUiOnFocusChange();
+public:
+void HandleOwnedSimulateKeyL();
+TBool HandleCcpuModeKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aEventCode,
+TKeyResponse& aRetCode, TBool aLongPressFlag = EFalse);
+	/**
+	*  Sets aFlag bitfield in iCcpuFlags
+	*/
+	inline void SetCcpuFlag(TInt aFlag);
+	/**
+	* Clears aFlag bitfield in iCcpuFlags
+	*/
+	inline void ClearCcpuFlag(TInt aFlag);
+	/**
+	* Clears all flags in iCcpuFlags
+	*/
+	inline void ResetCcpuFlags();
+	/**
+	* Returns ETrue if the aFlag bitfield in iCcpuFlags is set, EFalse if it
+	* is clear
+	*/
+	inline TBool IsCcpuFlagSet(TInt aFlag) const;
+/**
+* Check if Auto word Completion is Enabled
+*
+* @since 3.2
+* @return ETrue if Auto word Completion is enabled
+*/
+inline TBool IsAutoCompleteOn() const;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+* @return	TInt 	Typing correction level.
+*/
+inline TInt AdvancedPredictiveTypingCorrectionLevel() const;
+/**
+* @return   ETrue   If the number candidate shown. EFalse otherwise.
+*/
+inline TBool IsAdvancedPredictiveNumberCandidateShown() const;
+/**
+* Cuts off the automatically completed tail of the suggested word candidate.
+*/
+virtual void RemoveSuggestedAdvanceCompletionL();
+/**
+* @return   ETrue   If the number candidate shown. EFalse otherwise.
+*/
+inline TBool AdvancedPredictivePrimaryCandidate() const;
+TBool LongPressNumberEntryOnQwerty() const;
+// Predictive QWERTY (XT9) changs <----
+#endif //RD_INTELLIGENT_TEXT_INPUT
+/**
+* Returns ETrue if Feature manager supports Japanese.
+*/
+inline TBool IsFeatureSupportedJapanese() const;
+	/**
+* Cancels shift key timer.
+*/
+	void CancelShiftKeyTimer();
+/**
+* Queries supportting of SecretText
+*
+* @since 2.6
+* @return ETrue if SecretText was supported
+*/
+TBool IsSupportsSecretText() const;
+void SendEventsToPluginManL( TInt aEventType, TInt aEventData = 0 );
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+Sends the key event received to the Fn key handler and sets the Fn key state.
+*/
+TKeyResponse HandleFnKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aEventCode );
+#endif
+MAknFepManagerInterface* FepUI() const;
+TTmDocPosSpec DocPos();
+void HandleCopyCutEventL(TInt aCommandId);
+void LaunchPenSupportMenuL();
+private: //navigation
+void FindStartOfWord(TInt& aAnchorPos) const;
+void FindEndOfWord(TInt& aCursorPos) const;
+TBool CursorInsideWord();
+void MoveCursorToStartOfWordL();
+void MoveCursorToEndOfWordL();
+TKeyResponse HandleNaviEventOutsideInlineEditL(TUint aCode, TKeyPressLength aLength);
+TKeyResponse HandleWesternPredictiveArrowKeyL(TInt aCode, TKeyPressLength aLength);
+TBool TryHandleTextSelectedNaviEventL(TInt aCode, TKeyResponse& aResponse);
+TBool TryHandleCommonArrowAndBackspaceFunctionalityL(TInt aCode, TKeyResponse& aResponse);
+void TransferFepStateToEditorL(TBool aFnLockSync=ETrue);
+inline MAknFepManagerInterface* InternalFepUI();
+void LaunchLanguagesPopupListL(TBool aLaunchedByTouchWin = EFalse);
+void LaunchRecognitionWithDictionaryPopupListL();
+void LaunchWritingSpeedPopupListL();
+void LaunchGuidingLinePopupListL();
+TBool IsInputModeAvailable(TInt aMode) const;
+TInt NewInputModeAfterLanguageChange() const;
+/**
+* Launch User DB dialog
+* phrase creation
+* @since S60 5.0 S60_version
+* @param none
+* @return none
+*/
+void LaunchUserDBDlgL();
+/**
+* Set current input language and the capabilities of the language to
+* the iLanguageCapabilities member variable.
+*
+* @param aInputLanguage New (current) input language.
+*/
+void SetInputLanguageCapabilities(const TInt aInputLanguage);
+/**
+* Returns input language code that corresponds to UI language.
+*
+* @param aUiLanguage Ui language code.
+* @return Input language code that corresponds to the UI language code.
+*/
+TInt SubstituteSublanguageId(const TInt aUiLanguage) const;
+CTextView* TextView() const;
+CTextLayout* TextLayout() const;
+CPlainText* PlainText() const;
+void DoWesternMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+void DoChineseMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+void DoJapaneseMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+void DoChineseSubMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+TBool IsRightToLeftParagraph(TTmDocPosSpec aPos) const;
+void FindAdjacentChunks(const TTmDocPosSpec& aPos,
+CTmTextLayout::TTmChunkDescription& aLeft,
+CTmTextLayout::TTmChunkDescription& aRight) const;
+TBool GetNextVisualRightCharacter( TInt& aPosition );
+TBool GetNextVisualLeftCharacter( TInt& aPosition );
+void FindVisualRightOfWord(TInt& aPosition);
+void FindVisualLeftOfWord(TInt& aPosition);
+//
+// Remaining methods here are candidates for turning into TextViewUtility methods. Some
+// have been made static already in anticipation of this.
+//
+/**
+* Obtains the visual beginning of the document. This may be the left or right the right
+* end of the first line, depending on first paragraph's direction. If the beginning of the document
+* is currently not formatted, then EFalse is returned
+*
+* @param    aEndPos     DocPosSpec is returned for the visual beginning of the document.
+* @return   ETrue if the value is successfully calculated, that is the first line is formatted
+*/
+TBool GetVisualDocStart( TTmDocPosSpec& aStartPos ) const;
+/**
+* Obtains the visual end of the document. This may be the left or right the right
+* end of the last line, depending on last paragraphs direction. If the end of the document
+* is currently not formatted, then EFalse is returned
+*
+* @param    aEndPos     DocPosSpec is returned for the visual end of the document.
+* @return   ETrue if the value is successfully calculated, that is the last line is formatted
+*/
+TBool GetVisualDocEnd( TTmDocPosSpec& aEndPos ) const;
+/**
+* Get the document position of the visual extrem of the line in which the passed position
+* is in.
+*
+* @param aPos       A position within the line you are interested in
+* @param aToRight   ETrue if you want the right hand end.
+* @param aExtreme   Output value of the doc pos spec for the end of the line
+* @return           ETrue if the line was formatted. If False, the value of eExtreme
+* cannot be trusted.
+*/
+TBool GetAknFepLineExtreme( const TTmDocPosSpec& aPos, TBool aToRight,
+TTmDocPosSpec& aExtreme) const;
+/**
+* This is a very general routine for finding the visual extreme (according to
+* Avkon rules) of a piece of selected text.
+* - Text may in general have many varying directional sections.
+* - It may extend from one paragraph to another.
+* - If the paragraph directions are different the current input language is
+*
+* @param aSelection     Logical range for which the visual extreme is required
+* @param aEvent         The direction being navigated (Right/Left/Up/Down); eg. ELeftNaviEvent if moving to the left end
+* @param aLimitPos      returned position in document
+* @param aEffectiveRightOrLeftEvent  Pointer to TWesternNaviEvent, if passed from the client, will
+*                       return either ERightNaviEvent or ELeftNaviEvent
+*/
+void GetAvkonDefinedVisualLimitsOfSelection(
+const TCursorSelection& aSelection,
+TWesternNaviEvent aEvent,
+TTmDocPosSpec& aLimitPos,
+TWesternNaviEvent* aEffectiveRightOrLeftEvent) const;
+/**
+* Returns the position at the visual left extreme end for a logical range
+*
+* @param    aStartPos   Starting position for the search
+* @param    aMinPos     minimum logical position of the logical range
+* @param    aMaxPos     maximum logical position of the logical range
+* @return   TTmDocPosSpec for the visual left end
+*/
+TTmDocPosSpec LeftVisualExtremePos( const TTmDocPosSpec& aStartPos,
+TInt aMinPos, TInt aMaxPos ) const;
+/**
+* Returns the position at the visual right extreme end for a logical range. The range may consist
+* of many directional chunks.  They are iterated through until the visual end is found.
+*
+* @param    aStartPos   Starting position for the search
+* @param    aMinPos     minimum logical position of the logical range
+* @param    aMaxPos     maximum logical position of the logical range
+* @return   TTmDocPosSpec for the visual right end
+*/
+TTmDocPosSpec RightVisualExtremePos( const TTmDocPosSpec& aStartPos,
+TInt aMinPos, TInt aMaxPos ) const;
+/**
+* Gets the visual left-most position in a chunk within a logical range
+*/
+TBool LeftEndOfChunkWithinRange( const CTmTextLayout::TTmChunkDescription& aChunk,
+TInt aMinPos, TInt aMaxPos, TTmDocPosSpec& aNewPos) const;
+/**
+* Gets the visual right-most position in a chunk within a logical range
+*/
+TBool RightEndOfChunkWithinRange( const CTmTextLayout::TTmChunkDescription& aChunk,
+TInt aMinPos, TInt aMaxPos, TTmDocPosSpec& aNewPos) const;
+/**
+* Adjust the passed docpos to reflect the avkon principal that after a left navigation
+* the cursor should adhere to the bordering directional run on the left of that point.
+* This may mean that the logical position and leading/trailing feature of aPos are adjusted
+* This method does not perform the navigation, but may be called after a navigation.
+*/
+void AdjustPosSpecForAmbiguityAfterLeftOrRightNavigation( TTmDocPosSpec& aPos,
+TWesternNaviEvent aEvent ) const;
+/**
+* Do not move the visual position, but ensure that the docpos passed is adhering to the left
+* side of the right chunk passed in.
+*/
+static void AttachToRightChunk( TTmDocPosSpec& aPos,
+const CTmTextLayout::TTmChunkDescription& aRightChunk );
+/**
+* Do not move the visual position, but ensure that the docpos passed is adhering to the
+* right side of the left chunk passed in.
+*/
+static void AttachToLeftChunk( TTmDocPosSpec& aPos,
+const CTmTextLayout::TTmChunkDescription& aRightChunk );
+/**
+* Modify the cursor position after a jump to the start or end of a document.
+* The current input direction is used to modify the position, so as to avoid attaching the
+* new cursor position to a block of the opposite input directionality
+*
+* @param aPos   target position of the jump; may be modified by the routine.
+* @param aEvent navigation event that caused the loop.
+* @param aLoopToTop ETrue if the looping is from bottom to top; EFalse if from top to bottom
+*
+*/
+void AdjustPosSpecForInputLanguageAfterDocumentLoop( TTmDocPosSpec& aPos,
+TWesternNaviEvent aEvent,
+TBool aLoopToTop ) const;
+/**
+* Tests a chunk for validity.
+*
+* @return ETrue if the chunk is valid - is a real chunk.
+*/
+static TBool ChunkIsValid( const CTmTextLayout::TTmChunkDescription& aChunk );
+/**
+* Finds the current input direction. This is determined as best as it can using
+* - iT9Interface as the preferred source of information
+* if that is not active/defined then
+* - shared data (via AknTextUtils) if that fails
+* - localLanguage overrides may be in place
+*
+* - when fep is in numeric mode it returns LTR
+* - if FEP is in an irelevant mode, then LTR is returned
+*
+* Note that secret alpha modes return LTR always, as entry is alwas LTR for these
+*
+* @return TDirectionality::ERightToLeft when in an alpha mode and direction is RTL;
+*                           Otherwise returns ELeftToRight
+*/
+TBidiText::TDirectionality CurrentInputDirectionality() const;
+/**
+* Access the local language if defined
+*
+* @param aLanguage - returns the Symbian OS language code for the local language
+* @return EFalse iff no local language is in force
+*/
+TBool GetLocalLanguage( TLanguage& aLanguage ) const;
+/**
+* Looks through the FEP aware editor's text starting at character aPos, looking for a
+* strongly directional character.  Direction of search can be set.
+* Search is carried out until a strong character is found or the end (or beginning)
+* of the editor text has been reached.
+* The value returned in aIsRightToLeft should not be used unless the method returns ETrue
+* @param aPos       First character to look at
+* @param aForward   If EFalse, then search is backward (decreasing index) in logical buffer
+* @param aIsRightToLeft     Set to ETrue on return if first strong character found is RTL
+*
+* @return           EFalse if no strong character was found.
+*/
+TBool GetExposedDirectionOfText( TInt aPos, TBool aForward, TBool& aIsRightToLeft ) const;
+/**
+* Looks through the passed descriptor, looking for a strongly directional character.
+* Direction of search can be set. Search starts at the begining if searching forward;
+* starts at the end if searching backwards.
+*
+* Search is carried out until a strong character is found or the end (or beginning)
+* of the descriptor has been reached.
+* The value returned in aIsRightToLeft should not be used unless the method returns ETrue
+*
+* @param aText      Descriptor to search.
+* @param aForward   If EFalse, then search is backward (decreasing index) in logical buffer
+* @param aIsRightToLeft     Set to ETrue on return if first strong character found is RTL
+*
+* @return           EFalse if no strong character was found.
+*/
+TBool GetExposedDirectionOfTextInDescriptor( const TDesC& aText, TBool aForward,
+TBool& aIsRightToLeft ) const;
+/**
+* Access character in editor text at index aPos.
+*
+* @param    aPos    Index of character to access. Must be a valid index or panic may ensue.
+* @return           charater at index aPos; returns TChar(0) if cannot get at the text.
+*/
+TChar CharAt( TInt aPos ) const;
+/**
+* Navigate off of selected text using an Up/Down/Right/Left navigation event
+*
+* The code takes account of the paragraph directionality that the passed selection is
+* found in.
+*
+* The new cursor position is resolved for ambiguity and then set using SetCursorPosition, and
+* so it has the same side-effects:
+*   iUncommittedText is set to the zero-width "cursor" state with the new cursor position
+*   iUncommittedText is set into the FepAwareTextEditor state
+*   iCaseManager is updated with a ENullNaviEvent
+*   the doc pos is set in TextView object if present
+*
+* @param    aSelection  currently selected text
+* @param    aNaviEvent  navigation event. One of ERight/Left/Down/UpNaviEvent. Others are ignored
+* @param    aPos        Ouput, new position of the cursor
+* @return   EKeyWasNotConsumed if the key is not consumed
+*/
+TKeyResponse NavigateFromSelectionL(
+const TCursorSelection& aSelection,
+TWesternNaviEvent aNaviEvent,
+TTmDocPosSpec& aPos );
+/**
+* This method is the standard way for the FEP to move the cursor when there is
+* no inline edit or selection.
+* Side effects:
+* iUncommittedText is set to the zero-width "cursor" state with the passed position
+* iUncommittedText is set into the FepAwareTextEditor state
+* iCaseManager is updated with a ENullNaviEvent
+* the doc post is set in TextView object if present
+*
+* @param aNewCursorPos - defines the position to set the cursor at, including leading/trailing
+* @param aDragSelectOn - iff EFalse, do not keep old anchor position (that is, cancel any selection)
+* properties.
+*/
+void SetCursorPositionL( const TTmDocPosSpec& aNewCursorPos, TBool aDragSelectOn = EFalse );
+/**
+* Returns ETrue if the passed position is formatted and is in the first line
+*/
+TBool InFirstLineAndFormatted( const TTmDocPosSpec& aPos ) const;
+/**
+* Returns ETrue if the passed position is formatted and is in the last line
+*/
+TBool InLastLineAndFormatted( const TTmDocPosSpec& aPos ) const;
+/**
+* Returns ETrue if the passed position is in the
+* @param aCheckFirstLine    if ETrue, check for first line; else check last line
+* @return ETrue if the passed position is formatted and is first (or last - depending on switch)
+*/
+TBool DocPosInFirstOrLastLineAndFormatted( const TTmDocPosSpec& aPos,
+TBool aCheckFirstLine ) const;
+/**
+* Method to determine if the passed position is equivalent visually to the "canonical"
+* value determined by the limit algorithms.  The methods allow two visually equivalent,
+* but logically different TTmDocPosSpecs to be be checked for equivalence.
+* @param aCurrentPos    Position in document as returned by GetDocPos
+* @param aLimitPos      Visual start of document as returned by GetVisualDocStart
+* @returns              ETrue if the positions are visully equivalent
+*/
+TBool AtVisualStart( const TTmDocPosSpec& aCurrentPos, const TTmDocPosSpec& aLimitPos ) const;
+/**
+* Method to determine if the passed position is equivalent visually to the "canonical"
+* value determined by the limit algorithms.  The methods allow two visually equivalent,
+* but logically different TTmDocPosSpecs to be be checked for equivalence.
+* @param aCurrentPos    Position in document as returned by GetDocPos
+* @param aLimitPos      The visual end of document as returned by GetVisualDocStart
+* @returns              ETrue if the positions are visully equivalent
+*/
+TBool AtVisualEnd( const TTmDocPosSpec& aCurrentPos, const TTmDocPosSpec& aLimitPos,
+TInt aDocLength ) const;
+void SetCursorType(TBool aIsLeftToRight);
+TBool DeviceSupportsRTLLanguageL();
+	/**
+	 * Performs calculations of digit mode;
+	 * used in UpdateLocalDigitMode() and in UpdateNumericEditorDigitType()
+	 */
+	void CalculateEditorDigitType(TDigitType& aDestination);
+void UpdateNumericEditorDigitType();
+/**
+* Updates FEP digit mode from global locale settings.
+*/
+void UpdateLocalDigitMode();
+/**
+* Checks to see if the cursor position is at an ambiguous point (one where the text blocks
+* on either side are of different directionality) and potentially moves the cursor from
+* one block to the other, depending on the key identity.
+*
+* To be called before key event is processed by the FEP in the usual way.
+* If the key is acted upon to move the cursor, then the event is "eaten" and it is not
+* to be passed on for processing.
+*
+* @param aCode      Key code from standard TKeyEvent key event structure
+* @return           EKeyWasConsumed if a cursor adjustement was made;
+*                   else EKeyWasNotConsumed
+*/
+// TKeyResponse AttemptCursorFlipAtAmbiguousPointL( const TKeyEvent& aKeyEvent, TEventCode aEventCode );
+TKeyResponse AttemptCursorFlipAtAmbiguousPointL( const TUint aCode );
+/**
+* Call back method for the "Post Event Check" mechanism. Called from a CIdle after
+* any event that might required a check of the new cursor position or other invariant
+*/
+static TInt PostEventCheckCallback(TAny* aObj);
+/**
+* Access method for whether bidirectional cursor is to be used
+*
+* @return EFalse iff the bidi cursor is not to be used
+*/
+TBool BidiCursorRequired() const;
+/**
+* Since FEP does not complete the navigation of an event (editor and form do that), FEP
+* has to ensure after all navigation is finished if the cursor is displayed correctly.
+*
+* <p> This method, called from the post event callback, implements the action to check the
+* current cursor directionality against the text directionality at the cursor position,
+* and alters the cursor appearance as required.
+*/
+void DoCursorDirectionCheckL();
+/**
+* Check the directionality of text in the vicinity of the current document position
+* and ensure that the cursor is indicated appropriately.
+*
+* This routine has no side-effect on the cursor position. It merely changes the
+* appearance of the cursor.
+*/
+void AdjustCursorTypeForCurrentPosition();
+/**
+* Kicks off the post event check idle event
+*
+* @param aCode Key event code
+*/
+void SchedulePostEventCheckL(TUint aCode);
+/**
+* Check the directionality of text in the vicinity of the supplied document position
+* and ensure that the cursor is indicated appropriately.
+*
+* This routine has no side-effect on the cursor position. It merely changes the
+* appearance of the cursor.
+*
+* @param    aDocPos     document position that is to be analysed and acted on
+*/
+void AdjustCursorTypeForPosition( const TTmDocPosSpec& aDocPos );
+/**
+* "Hook" method for managing a bidi cursor according to the text directionality at the cursor
+* Only one of this method or SetCursorTypeForInputDirection will be in operation at any
+* time.
+*
+* @param aLeftToRight   Supply ETrue iff cursor required is LTR cursor
+*/
+void SetCursorTypeForTextDirection( TBool aLeftToRight );
+/**
+* "Hook" method for managing a bidi cursor according to the current input direction
+* Only one of this method or SetCursorTypeForTextDirection will be in operation at any
+* time.
+*
+* @param aLeftToRight   Supply ETrue iff cursor required is LTR cursor
+*/
+void SetCursorTypeForInputDirection( TBool aLeftToRight );
+/**
+* Routine to analyse the directionalities surrounding the supplied document position
+* and to return the results.
+*
+* @param    aDocPos     document position that is to be analysed
+* @return               Structure containing the results of the analysis
+*/
+TTextDirectionalInfo LocalTextDirectionalStatus( const TTmDocPosSpec& aDocPos ) const;
+/**
+*
+* This method is used to add directional markers to protect neutrals that may be
+* exposed to the opposite directional formatting to their situation before the deletion
+*
+* Redecoration is carried out if a neutral is exposed by the deletion to a directionality
+* different to that which is was already marked.
+*
+* An inline edit may be stated and then committed.
+*
+* iUncommittedText is required to be set to the cursor position that existed after
+* the deletion.
+*
+* iUncommittedText will be updated to the new cursor position.
+*
+* @param aTextThatWasDeleted Informs the method of what text has just been removed
+*/
+void RedecorateAfterDeletionL( const TDesC& aTextThatWasDeleted );
+TBool EditorSupportsNeutralProtection();
+/**
+* Wrapper function for the MCoeFepAwareTextEditor commit method.
+* This method terminates the inline by accepting the current inline edit into the buffer.
+*
+* At entry, iUncommittedText is required to have the span of the current inline edit.
+* iAnchorPos should be the index of the first character in the inline edit.
+* iCursorPos should be the index of the next character after the inline edit.
+*
+* At exit, iUncommittedText has 0-length and represents the current cursor position.
+* That is, iAnchorPos = iCursorPos = index of the character next after the cursor
+*
+* These indices may be more easily though of as "gap indices" where gap 0 precedes
+* character 0, gap 1 follows character 0, gap 2 follows charcacter 1, etc.. until gap
+* N follows character (N-1).
+*
+* This routine does not attempt to consolidate any directional markers that may be
+* extraneous in the new buffer.  It is therefore used when it is important to know what
+* span after the commit, e.g. to make it reversible.
+*
+* @param aFepAwareTextEditor    Editor for which there is a current inline edit.
+* @param aCursorVisibility      EFalse if the cursor is to be suppressed during the commit.
+*/
+void CommitInlineEditWithoutResolutionL(MCoeFepAwareTextEditor& aFepAwareTextEditor,
+TBool aCursorVisibility, TBool aClearPti = ETrue);
+TKeyResponse HandlePredictiveNaviEventOutsideInlineEditL(TUint aCode, TKeyPressLength aLength);
+static TInt DoSimulateKey(TAny* aThisPtr);
+/**
+* This method is that the label of CBA is updated by aTextResId.
+* @param aPosition   CBA position, either ELeftSoftkeyIndex or ERightSoftkeyIndex
+* @param aCommandId  command id for softkey
+* @param aTextResId  resource id to set string on label.
+* @return TBool The return value is ETrue in case it is necessary to update CBA.
+*/
+TBool UpdateCBALabelL(TInt aPosition, TInt aCommandId, TInt aTextResId);
+/**
+* Launches special character table (SCT) and pictograph character table (PCT).
+*
+* @param aResourceId   Resource of SCT content. NULL if the default SCT content
+*                      is used. At the moment only Thai language sets non-default
+*                      content.
+* @param aShowSctParam Set the show mode for sct. EShowSctFirst or EShowPctFirst or EShowSmileyFirst
+*/
+void DoLaunchSctAndPctL(TInt aResourceId, TShowSctMode aShowSctMode);
+/**
+* Update CangJie mode
+*
+* @param aNewMode   New CangJie mode
+* @since 3.0
+*/
+	void UpdateCangJieState(TInt aNewMode);
+/**
+* Launch CangJie setting dialog
+*
+* @since 3.0
+* @return  Selected CangJie level or KErrGeneral if user cancel the selection
+*/
+	TInt LaunchCangJieOptionDlgL();
+	void AddEditSubmenuL(CAknFepUiInterfaceMenuPane* aMenuPane);
+	void DisableEditSubmenuItems(CAknFepUiInterfaceMenuPane* aMenuPane);
+	void StartCcpuModeL(TBool aCopyMode);
+/**
+* Handle the Chr Key Monitor
+* for Japanese variant only.
+*
+* @since 3.0
+*/
+void HandleChrKeyMonitorL();
+TBool IsCursorAtEndOfWord();
+/* This method should be called after launching any dialog by FEP */
+void PrepareFepAfterDialogExitL(TUid aFepUid);
+/* This method should be called before launching any fep aware dialog by FEP */
+void PrepareFepForFepAwareDialogLaunch();
+/* This method should be called after launching any fep aware dialog by FEP */
+void PrepareFepAfterFepAwareDialogExitL(TUid aFepUid);
+public:
+/**
+* Handle layout change.
+* When screen layout change, Key Catcher calls this method
+*
+*/
+void HandleResourceChange(TInt aType);
+TBool IsHybridAplhaEditor() const;
+TBool IsHybridAlphaModeChangedtoAplhanumeric() const;
+TBool QueryPredictiveState(const TAknEditingState aState);
+TInt EvaluateState(TAknEditingState aState);
+TBool QueryPredictiveAutoCompleteState(TAknEditingState aState);
+	 CAknExtendedInputCapabilities::TEditorType EditorType() const;
+	 TUint MIDPConstraint() const;
+	/**
+	* Tells if the current editor is phone number editor
+	* @return ETrue if the current editor is phone number editor
+	*/
+	TBool IsPhoneNumberEditor() const;
+#ifdef RD_SCALABLE_UI_V2
+/**
+* Pen input support functions
+*/
+public:
+void HandlePointerEventL(const TPointerEvent &aPointerEvent);
+/**
+* Handle arrow key event when some chars have been selected
+*
+* @since S60 v3.2
+* @param aKeyEvent
+* @param aEventCode
+* @param aRetCode
+*/
+TBool HandleSelModeArrowKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aEventCode,
+TKeyResponse& aRetCode);
+/**
+* From CAknExtendedInputCapabilities::MAknEventObserver
+* Handle an event
+*
+* @since S60 v3.2
+* @param aEvent An event, see TInputCapabilitiesEvent
+* @param aParams Event dependent parameters
+*/
+void HandleInputCapabilitiesEventL( TInt aEvent, TAny* aParams );
+void SubmitInlineTextL( const TDesC& aData );
+inline TInt PermittedModes() const;
+inline void SetNotifyPlugin( TBool aNotifyFlag );
+inline void RemeberEditorState();
+inline TBool IsMfneEditor() const;
+inline TBool IsFindPaneEditor() const;
+inline TBool IsSupportedAdaptiveSearch() const;
+//for japanese
+void NotifyJapaneseSetting();
+void ProcessEditorMenuCommand(TInt aCommand);
+TInt GetPermittedEditorMenu(TBool aOnlyCount = EFalse);
+void UpdateTouchCaseMode();
+	void DimInputmodeTouchMenuItems(CAknFepUiInterfaceMenuPane* aMenuPane);
+	inline TLanguageCapabilities InputLanguageCapabilities() const;
+inline TAknFepManagerState& FepManState();
+inline TBool IsSupportNativeNumber() const;
+	void NeedDisableKeySound(const TKeyEvent& aKeyEvent, TEventCode aEventCode);
+	inline void SetGainForeground( TBool aGainForeground );
+	void HandleEndKeyL();
+	inline void SetCancelPopupInQwerty( TBool aCancelPopupInQwerty );
+/**
+* Return the chinese input mode used last time
+*/
+	inline TInt LastChineseInputMode() const;
+/**
+* Return active input language, only used for languages popup list
+*/
+inline TInt ActiveInputLanguage() const;
+/**
+* Set active input language, only used for languages popup list
+*/
+inline void SetActiveInputLanguage(TInt aInputLanguage);
+private:
+/**
+* Checks if the current editor is fully FEP aware.
+*
+* @since 3.2
+*
+* @return ETrue if editor if fully FEP aware.
+*/
+TBool FullyFepAwareTextEditor() const;
+/**
+* Checks if the current editor is partially FEP aware.
+*
+* @since 3.2
+*
+* @param aAtLeast if ETrue then ETrue is returned for also fully FEP aware editors.
+*
+* @return ETrue if editor is partially FEP aware.
+*/
+TBool SemiFepAwareTextEditor( TBool aAtLeast = EFalse ) const;
+void DoWesternTouchMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+void DoChineseTouchMenu(CAknFepUiInterfaceMenuPane* aMenuPane);
+/**
+* Checks if the current input mode belongs to chinese input modes.
+*
+* @param aMode The current input mode.
+*
+* @return ETrue if the current input mode belongs to chinese input mode..
+*/
+TBool IsChineseInputMode( TInt aMode );
+#endif //RD_SCALABLE_UI_V2
+/**
+* Returns the type of the focused editor.
+*
+* @since 3.2
+*
+* @return Editor type.
+*/
+//CAknExtendedInputCapabilities::TEditorType EditorType() const;
+/**
+*  Get the MAknFepDocumentNavigation object
+*
+*  @since 3.2
+*  @return pointer to MAknFepDocumentNavigation accessed through
+*  the input capabilites object provider.
+*/
+	MAknFepDocumentNavigation* AknFepDocumentNavigation() const;
+	TInt GetPermittedEditorMenuL(TBool aOnlyCount = EFalse);
+private:// from MPeninputServerEventHandler
+void UpdateLatinIndicator( TAknEditingState& aNewState );
+void UpdateNumberIndicator( TAknEditingState& aNewState );
+void UpdateHindiIndicator( TAknEditingState& aNewState );
+void HandleCopyCutStateL();
+	/**
+	* Returns ETrue if hash key selection is on and hash key mode selection should
+	* be blocked.
+	*
+	* @since 3.1
+	*/
+TBool HashKeyModeChangeBlockedInSearchField() const;
+/**
+* Set editor cursor selection according plugin UI
+* cursor state
+*
+* @since 3.2
+* @param aCurSel Cursor position.
+* @param aSyncCursor ETrue if plug in UI need update cursor, EFalse otherwise
+* @return None
+*/
+void SetCursorSelectionL(const TCursorSelection& aCurSel, TBool aSyncCursor);
+	/**
+* An internal helper method for matches popup list.
+*
+* The index of currently selected prediction candidate.
+*
+* @since S60 3.2
+*/
+TInt ResolveCurrentCandidateListIndex(CDesCArrayFlat* aCandList);
+/**
+	*  Removes underlining from predictive word and moves cursor the end of the word.
+	*
+*  @since 3.2
+*  @param aData Key data
+*  @return None
+*/
+void DeactivatePredicitveWordAndMoveCursorL();
+	/**
+	*  Returns the Ccpu status of given editor state as a flag combination.
+	*
+*  @since 3.2
+*  @param aEdwinState
+*  @return editor ccpu status
+*/
+	TInt EditorCcpuStatus(CAknEdwinState* aEdwinState);
+	/**
+	*  Cancels editing options copy / paste mode initialted from editing options -submenu.
+	*
+*  @since 3.2
+*/
+	void CancelCcpuMode();
+#ifdef RD_SCALABLE_UI_V2
+/**
+*  Launches stylus Ccpu-menu
+*
+*  @since 5.0
+*  @param aClickPoint Point where stylus was clicked.
+*/
+void LaunchStylusCcpuMenuL(TPoint &aClickPoint);
+void DynInitTouchMenuPaneL(CAknFepUiInterfaceMenuPane* aMenuPane);
+#endif
+/**
+* Has Japanese prediction input mode in PtiEngine
+*/
+TBool HasJapanesePredictionInputMode() const;
+void InitPreviewMenuPane(CAknFepUiInterfaceMenuPane* aMenuPane);
+public:
+void StopDisplayingMenuBar();
+private:
+void ConvertCharToKey(TChar aIn, TUint16& aKey) const;
+/**
+* Update editor state' flag
+* @since Symbian^3
+* @param aFlag  editor state flag
+* @param aAdd   adding or removing
+*/
+void UpdateEditorStateFlags( TInt aFlag, TBool aAdd = ETrue ) const;
+private:
+// Data owned by this class
+CAknFepKeyCatcherInterface* iKeyCatcher;
+CAknFepIndicator* iIndicator;
+CPeriodic* iShiftKeypressMonitor;
+CAknFepLanguageManager* iLangMan;           // own
+MAknFepManagerInterface* iCurrentFepUI;     // not own
+CAknFepCaseManager* iCaseMan;
+CAknFepInlineTextDecorator* iInlineTextDecorator;
+CAknFepHashKeyManager* iHashKeyMan;
+CPeriodic* iConcatenationTimer;
+//fep delay the resource changed message for getting the updated coordinate from editor.
+CAsyncCallBack iAsyncResouceChanged;
+// shared data support
+CAknFepSharedDataInterface* iSharedDataInterface;
+MAknEditingStateIndicator*  iPreviousIndicator;
+MAknEditingStateIndicator* iEditIndicatorAtLastUpdate;
+TAknEditingState iPreviousEditingState;
+TLanguage iUiLanguage;  // Symbian language code for UI language.
+TLanguageCapabilities iLanguageCapabilities; // Input language and capabilities of the language.
+TUint iFlags;
+TUint iExtendedFlags;
+TAknFepManagerState iFepManState;
+TCoeInputCapabilities iInputCapabilities;
+TInt iPermittedInputModes;
+TInt iMode;
+TInt iModeBefore;
+TInt iCaseBefore;
+TInt iResId;
+TInt iVariantPermittedModes;
+TInt iSpaceCharacterCode;               // adding for japanese
+TInt iFullWidthSpaceCharacterCode;      // adding for japanese
+TAknEditorNumericKeymap iAknEditorNumericKeymap;
+TInt iAknEditorFlags;
+TCursorSelection iUncommittedText;
+RArray<TInt> iHashKeyLoop;
+TBool iWesternPredictive;
+TKeyPressLength iKeyRepeat;
+TBool iIsAutoCompleteOn;				// for Auto Word Completion
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+TInt iKeyBackSpaceHit;
+TInt  iTypingCorrectionLevel;			// for typing correction level
+TBool iIsNumberCandidateShown;			// for number candidates
+TBool iPrimaryCandidate;    			// for primary candidate
+TBool iKeyPressedDuringShift;
+TPtiKeyboardType iKeyboardType; 		// for checking the keyboard layout
+TBool iSupressCursorMoveToEndChrKeyPressed; // For supressing cursor movement when SCT launched
+#endif //RD_INTELLIGENT_TEXT_INPUT
+TBool iJapanesePredictive;
+TBool iDeviceSupportsRtlLanguage; // Could be removed
+CIdle* iPostEventCheck; // Owned
+TWidthChar iCharWidth;      // adding for japanese
+CPtiEngine* iPtiEngine;     // adding for japanese
+TUint iSimulateKey;
+CApaDocument* iEmbedded; // User Dictionary
+CAknNullService*  iNullService; // User Dictionary
+CAsyncCallBack iAsyncOwnSimulateKey;
+TInt iFreeSpaceOfEditor;
+TBool iQwertyInputMode; // Not used. The value is always EFalse.
+TBool iLongThai0Key;
+TBool iFepFullyConstructed;
+CAknEdwinState* iRememberEditorState; // For "editing options" submenu
+TInt iRememberLength;   // For "editing options" submenu.
+TInt iEditorCcpuStatus; // For "editing options" submenu.
+TInt iCcpuMode;         // For "editing options" submenu
+TInt  iMultiTapTimer;   // for Japanese only: store MultiTap Timer
+	CAknFepUiInterfaceMenuBar* iEditMenuBar;   // Remember menu bar instance for closing.
+	HBufC* iSctEditChars;   // Buffer for characters selected in the edit menu
+	TPtr iEditCharsPtr;     // Pointer to the buffer that holds all the selected characters.
+	TInt iStarScan;         // Remember scan code for star key.
+TInt  iJapaneseQwertyFlags;   // for Japanese only: store Japanese Qwerty Flags
+CPeriodic* iChrKeypressMonitor; // for Japanese only: Chr key monitor timer
+	TBool iLastKeyPressedWasHashKey;
+TBool iStopProcessFocus;
+TBool iClosePeninputUi;
+/**
+* User DB dialog
+* Own, but doesn't need delete by myself
+*/
+CAknFepUserdbDlg* iUserdbdlg;
+CAknNavigationDecorator* iTapGroup;
+TInt iEditorCommandList[30];
+	TBool iComposChrFlag;
+//User db view(phrase creation)
+TInt iIsUserdbdlgActive;
+/**
+* * Used for handle key event for zhuyin method.(phrase creation)
+*
+*/
+CZhuyinKeyHandler* iZhuyinKeyHandler;
+CAknFepZhuyinAnalyser* iZhuyinAnalyser;
+CZhuyinAnalyserDbFeed* iZhuyinAnalyserDb;
+#ifdef RD_SCALABLE_UI_V2
+/**
+* Used by itut spell mode, initial text in spell mode
+*/
+	HBufC* iSpellInitText;
+/**
+* Used by itut spell mode, initial text selection in spell mode,
+* whose position is relative to whole text in original editor
+*/
+	TCursorSelection iSpellInitCurSel;
+CAknFepPluginManager* iFepPluginManager;
+/**
+* HKB predictive state before starting plugin IME
+*/
+TBool                    iT9UsedBeforePluginInput;
+/**
+* Stylus ccpu menu
+*/
+CAknFepUiInterfaceStylusPopUpMenu*     iStylusCcpuMenu;
+/**
+* Last known clik point, needed for stylus ccpu menu launch.
+*/
+TPoint                   iClickPoint;
+TBool iGainForeground;
+TBool iLoseForeAndGainFocus;
+TBool iNotifyPlugin;
+TBool iCancelPopupInQwerty;
+TBool iStarKeyPressed;
+TInt iLastChineseInputMode;
+// Indicate Stroke is used in QWERTY, when default input mode is Cangjie
+TBool iStrokeUsedInQWERTY;
+// Save that which editor use stroke
+CAknEdwinState* iEditorStateStrokeUsed;
+#endif //RD_SCALABLE_UI_V2
+/**
+* Long press clear key after close UI;
+*/
+TBool                    iLongClearAfterCloseUI;
+TBool iFeatureSupportedJapanese;    // Save the value of KFeatureIdJapanese
+	// stores a reference to previous editor state for pointer comparision
+	CAknEdwinState* iPreviousEditorState;
+CAknFepUIInterface* iUiInterface;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+CAknFepFnKeyManager     *iFnKeyManager; // Owned
+TBool iIsFnKeyMapped;
+#ifdef __REVERSE_FN_KEY_SUPPORTED
+TBool iIsReverseFnkeyInput;
+#endif //__REVERSE_FN_KEY_SUPPORTED
+	// Predictive QWERTY (XT9) changes ---->
+//! The exact word tooptip shown above the inline editor when the exact word differs from the best guess candidate
+// CAknPreviewPopUpController* iExactWordPopup;
+//! The contents of the exact word popup.
+	MAknFepUiWordPopupContent* iExactWordPopupContent;
+	MAknFepCandidatePopup*	iCandidatePopup;
+	TBool iSListLaunchedFromMenu;
+	TInt iAutoCmptnTailLength;
+	TInt iIsLastResourceEditMenu;
+	// Predictive QWERTY (XT9) changes <----
+#ifdef    __ITI_VIRTUAL_TOUCH_FIRST_GENERATION_SUPPORT__
+CAknFepUiInterfaceMenuBar* iOptionsMenuBar;
+#endif
+#endif //RD_INTELLIGENT_TEXT_INPUT
+//phrase creation
+TInt iPhraseCreation;
+TInt iPinyinPhraseCreation;
+TInt iKeyStar;
+TInt iEntryPhrase;
+TBool iPenSupportMenu;
+TFepSymbolOfHardwareOne iSymbolData;
+/**
+* Flag for wether input mode is changed by shift+space
+*/
+TBool iShiftAndSpace;
+CAknFepThaiSCTSelector* iAknFepThaiSCTSelector;
+/**
+* Active input language, only used for languages pop up list,
+* can not changed in other cases, e.g. in latin-only editor
+*/
+TInt iActiveInputLanguage;
+/**
+* indicate whether matches popup list was lauched,
+* when rotating the screen, we need to consider it, e.g V-ITUT  to FSQ
+*/
+TBool iMatchesListLaunched;
+/**
+* monitor the long press event from Fn key
+* when long press event occurs, Fn key will be set to Lock state
+*/
+CPeriodic* iFnKeypressMonitor;
+public:
+//the follow 8 functions for phrase creation
+/**
+* Set the state to pinyin phrase creation
+*/
+void PinyinPhraseCreation( TBool aPinyinPhraseCreation );
+/**
+* Is the state is in pinyin phrase creation
+*
+* @return if not enabled, return EFalse
+*/
+TBool IsPinyinPhraseCreation() const;
+/**
+* Set the state to phrase creation
+*/
+void PhraseCreation( TBool aPhraseCreation );
+/**
+* Is the state is in phrase creation
+*
+* @return if not enabled, return EFalse
+*/
+TBool IsPhraseCreation() const;
+/**
+* Set the state to input phrase
+*/
+void EntryPhrase( TBool aEntryPhrase );
+/**
+* Is the state is in input phrase
+*
+* @return if not enabled, return EFalse
+*/
+TBool IsEntryPhrase() const;
+/**
+* Set the state to enable star key
+*/
+void EnableKeyStar( TBool aEnable );
+/**
+* Is the state is enable star key
+*
+* @return if not enabled, return EFalse
+*/
+TBool IsEnableKeyStar() const;
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+public:
+/**
+* multitaps thru the chars in the SCT.
+* @param aCallback, the callback when the timer expires
+*/
+void MultitapThroughSCTCharL(TCallBack aCallBack);
+/**
+* Notify mfne editor to toggle AM or PM for 12-hour time
+*/
+void ChangeMfneAmPm();
+private:
+TBool NumericResourceMultiTapTimerTimeoutL();
+/**
+* CAknFepManager::FindAndRemoveInputOptionsMenuItemL
+* Helper method to check if the "Input options" menu item exists and
+* if so, remove it from the menu pane.
+*  Params -
+*      aMenuPane : pointer to the menu pane to be checked for the resource id
+*/
+void FindAndRemoveInputOptionsMenuItemL( CAknFepUiInterfaceMenuPane* aMenuPane );
+/**
+* CAknFepManager::FindAndRemoveEditSubMenuItemL
+* Helper method to check if the "Edit Text" menu item exists and
+* if so, remove it from the menu pane.
+*  Params -
+*      aMenuPane : pointer to the menu pane to be checked for the resource id
+*/
+void FindAndRemoveEditSubMenuItemL( CAknFepUiInterfaceMenuPane* aMenuPane );
+/**
+* CAknFepManager::AddInputOptionsMenuItemL
+* Helper method to add the "Input options" menu item in appropriate location
+* Appropriate location is :
+*  - if Avkon Help command exists, then immediately above it
+*  - else if Avkon Exit command exists, then immediately above it
+*  - else if there are 3 or more items in the Options menu, then 3rd from last
+*  - else it is the last item.
+*  Params -
+*      aMenuPane : pointer to the menu pane to be checked for the resource id
+*/
+void AddInputOptionsMenuItemL( CAknFepUiInterfaceMenuPane* aMenuPane );
+private:
+CChrMultiTapTimer* iNumericResourceTimer;
+HBufC* iResourceString;
+TInt iChrCharIndex;
+#ifdef __HALF_QWERTY_KEYPAD
+	TKeyEvent iHalfQwertyLastKeyEvent;
+// this variable is set whenever a long key press of chr happens
+	TBool iChrLongKeyPress;
+TBool iFnCharInsertedForShift;
+#endif //__HALF_QWERTY_KEYPAD
+TInt iNumericResourceId;
+#endif //RD_INTELLIGENT_TEXT_INPUT
+TBool iHybridAplphaChangedToAlphanumeric;
+CAknEdwinState* iLastFocusedEditor;
+CAknEdwinState* iFepAwareDialogParentEditor;
+/**
+* Indicate that the focused control is destroyed.
+*/
+TBool iFocusedItemDestroy;
+};
+/**
+*  Sets aFlag bitfield in iFlags
+*/
+inline void CAknFepManager::SetFlag(TInt aFlag)
+{
+iFlags|=aFlag;
+}
+/**
+* Clears aFlag bitfield in iFlags
+*/
+inline void CAknFepManager::ClearFlag(TInt aFlag)
+{
+iFlags&=~aFlag;
+}
+/**
+* Clears all flags down
+*/
+inline void CAknFepManager::ResetFlags()
+{
+iFlags=0;
+}
+/**
+* Returns ETrue if the aFlag bitfield in iFlags is set, EFalse if it
+* is clear
+*/
+inline TBool CAknFepManager::IsFlagSet(TInt aFlag) const
+{
+return iFlags&aFlag;
+}
+/**
+*  Sets aExtendedFlag bitfield in iExtendedFlags
+*/
+inline void CAknFepManager::SetExtendedFlag(TInt aExtendedFlag)
+{
+iExtendedFlags|=aExtendedFlag;
+}
+/**
+* Clears aExtendedFlag bitfield in iExtendedFlags
+*/
+inline void CAknFepManager::ClearExtendedFlag(TInt aExtendedFlag)
+{
+iExtendedFlags&=~aExtendedFlag;
+}
+/**
+* Clears all ExtendedFlags down
+*/
+inline void CAknFepManager::ResetExtendedFlags()
+{
+iExtendedFlags=0;
+}
+/**
+* Returns ETrue if the aExtendedFlag bitfield in iExtendedFlags is set, EFalse if it
+* is clear
+*/
+inline TBool CAknFepManager::IsExtendedFlagSet(TInt aExtendedFlag) const
+{
+return iExtendedFlags&aExtendedFlag;
+}
+/**
+* Returns previous case information
+*/
+inline TInt CAknFepManager::CaseBefore() const
+{
+return iCaseBefore;
+}
+inline TBool CAknFepManager::IsChineseInputLanguage() const
+{
+return ( iLanguageCapabilities.iInputLanguageCode == ELangPrcChinese ||
+iLanguageCapabilities.iInputLanguageCode == ELangHongKongChinese ||
+iLanguageCapabilities.iInputLanguageCode == ELangTaiwanChinese);
+}
+inline TBool CAknFepManager::IsKoreanInputLanguage() const
+{
+return iLanguageCapabilities.iInputLanguageCode == ELangKorean;
+}
+inline TBool CAknFepManager::IsArabicInputLanguage() const
+{
+return ( iLanguageCapabilities.iInputLanguageCode == ELangArabic);
+}
+/**
+* Returns the valid of Qwerty
+*/
+inline TBool CAknFepManager::IsQwerty() const
+{
+return iQwertyInputMode;
+}
+/**
+*  Sets aFlag bitfield in iCcpuFlags
+*/
+inline void CAknFepManager::SetCcpuFlag(TInt aFlag)
+{
+iCcpuMode|=aFlag;
+}
+/**
+* Clears aFlag bitfield in iCcpuFlags
+*/
+inline void CAknFepManager::ClearCcpuFlag(TInt aFlag)
+{
+iCcpuMode&=~aFlag;
+}
+/**
+* Clears all flags in iCcpuFlags
+*/
+inline void CAknFepManager::ResetCcpuFlags()
+{
+iCcpuMode=0;
+}
+/**
+* Returns ETrue if the aFlag bitfield in iCcpuFlags is set, EFalse if it
+* is clear
+*/
+inline TBool CAknFepManager::IsCcpuFlagSet(TInt aFlag) const
+{
+return iCcpuMode&aFlag;
+}
+inline MAknFepManagerInterface* CAknFepManager::InternalFepUI()
+{
+return iCurrentFepUI;
+}
+#ifdef RD_SCALABLE_UI_V2
+inline void CAknFepManager::SetNotifyPlugin( TBool aNotifyFlag )
+	{
+	iNotifyPlugin = aNotifyFlag;
+	}
+inline TInt CAknFepManager::PermittedModes() const
+	{
+	return iPermittedInputModes;
+	}
+inline void CAknFepManager::RemeberEditorState()
+	{
+	iRememberEditorState = EditorState();
+	}
+inline TBool CAknFepManager::IsMfneEditor() const
+{
+return EditorType() == CAknExtendedInputCapabilities::EMFNEBased;
+}
+inline TBool CAknFepManager::IsFindPaneEditor() const
+{
+return iAknEditorFlags & EAknEditorFlagFindPane;
+}
+inline CAknFepManager::TLanguageCapabilities CAknFepManager::InputLanguageCapabilities() const
+{
+return iLanguageCapabilities;
+}
+inline TAknFepManagerState& CAknFepManager::FepManState()
+{
+return iFepManState;
+}
+inline void CAknFepManager::SetCancelPopupInQwerty( TBool aCancelPopupInQwerty )
+{
+iCancelPopupInQwerty = aCancelPopupInQwerty;
+}
+inline TInt CAknFepManager::LastChineseInputMode() const
+{
+return iLastChineseInputMode;
+};
+#endif //RD_SCALABLE_UI_V2
+/**
+* Returns ETrue if Feature manager supports Japanese.
+*/
+inline TBool CAknFepManager::IsFeatureSupportedJapanese() const
+{
+return iFeatureSupportedJapanese;
+}
+/**
+* Returns ETrue if Auto Word Completion is enabled in the edtior
+*/
+inline TBool CAknFepManager::IsAutoCompleteOn() const
+{
+return iIsAutoCompleteOn;
+}
+#ifndef RD_INTELLIGENT_TEXT_INPUT
+/**
+* Setes the current state from GS to the local state
+*/
+inline void CAknFepManager::SetAutoCompletionState(TInt aValue)
+{
+	iIsAutoCompleteOn = aValue;
+}
+#endif
+#ifdef RD_INTELLIGENT_TEXT_INPUT
+/**
+* @return	TInt 	Typing correction level.
+*/
+inline TInt CAknFepManager::AdvancedPredictiveTypingCorrectionLevel() const
+	{
+		return iTypingCorrectionLevel;
+	}
+/**
+* @return   ETrue   If the number candidate shown. EFalse otherwise.
+*/
+inline TBool CAknFepManager::IsAdvancedPredictiveNumberCandidateShown() const
+	{
+	return iIsNumberCandidateShown;
+	}
+/**
+* @return   ETrue   If the number candidate shown. EFalse otherwise.
+*/
+inline TBool CAknFepManager::AdvancedPredictivePrimaryCandidate() const
+	{
+	return iPrimaryCandidate;
+	}
+#endif //RD_INTELLIGENT_TEXT_INPUT
+inline TBool CAknFepManager::WasLastKeyPressAHashKey()
+	{
+	return iLastKeyPressedWasHashKey;
+	}
+inline void CAknFepManager::SetLastPressedHashKeyStatus(TBool aStatus)
+	{
+	iLastKeyPressedWasHashKey = aStatus;
+	}
+inline TCoeInputCapabilities& CAknFepManager::InputCapabilities()
+{
+return iInputCapabilities;
+}
+inline TFepSymbolOfHardwareOne CAknFepManager::SymbolInfoOfHardKey1()
+{
+return iSymbolData;
+}
+inline TBool CAknFepManager::IsSupportNativeNumber() const
+{
+return ( iLanguageCapabilities.iLocalDigitType == EDigitTypeArabicIndic
+|| iLanguageCapabilities.iLocalDigitType == EDigitTypeEasternArabicIndic
+|| iLanguageCapabilities.iLocalDigitType == EDigitTypeDevanagari );
+}
+inline TBool CAknFepManager::IsSupportedAdaptiveSearch() const
+{
+return iAknEditorFlags & EAknEditorFlagAdaptiveSearch;
+}
+inline void CAknFepManager::SetGainForeground( TBool aGainForeground )
+{
+iGainForeground = aGainForeground;
+}
+/**
+* Return active input language, only used for languages popup list
+*/
+inline TInt CAknFepManager::ActiveInputLanguage() const
+{
+return iActiveInputLanguage;
+}
+/**
+* Set active input language, only used for languages popup list
+*/
+inline void CAknFepManager::SetActiveInputLanguage( TInt aInputLanguage )
+{
+iActiveInputLanguage = aInputLanguage;
+}
+#endif
+// End of file

branch	RCL_3
changeset 44	ecbabf52600f
child 50	5a1685599b76