1 /*

     2 * Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:           

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 #ifndef __AKN_FEP_PLUGIN_MANAGER__

    30 #define __AKN_FEP_PLUGIN_MANAGER__

    31 

    32 // INCLUDES

    33 #include <gulicon.h>

    34 #include <barsread.h>

    35 #include <aknfeppensupportinterface.h>

    36 #include <peninputclient.h>

    37 #include <aknextendedinputcapabilities.h>

    38 #include <eikedwob.h>          // for MEikEdwinObserver

    39 

    40 #include "AknFepGlobalEnums.h"

    41 #include <aknfeppeninputenums.h>

    42 #include "AknFepPluginMenuManager.h"

    43 #include "AknFepSharedDataInterface.h"

    44 #include "AknFepManager.h"

    45 #include "AknFepCaseManager.h"

    46 #include <peninputsrveventhandler.h>

    47 

    48 // FORWARD DECLARATIONS

    49 //class MPeninputServerEventHandler;

    50 class MAknFepManagerInterface;

    51 class CAknFepUiSpellContainer;

    52 class CPenInputGSInterface;

    53 class CConnectAo;

    54 

    55 // CLASS DECLARATION

    56 

    57 

    58 /** 

    59  * Plugin command type

    60  */

    61 enum TPluginCmd

    62     { 

    63     EPluginCloseMode,

    64     EPluginSyncFepAwareText,

    65     EPluginSetDataQueryShown,

    66     EPluginActivate,

    67     EPluginMenuCmd,

    68     EPluginFocusChanged,

    69     EPluginResourceChanged,

    70     EPluginFaseSwap,

    71     EPluginKeyEvent,

    72     EPluginUpdateIndicator,

    73     EPluginActivateInGlobalNote,

    74     EGainForeground,

    75     ELostForeground,    

    76     EPluginEditorActivate,

    77     EPluginForegroundChanged,

    78     EPluginFocusItemDestroy,

    79     EPluginLanguageChanged,

    80     EPluginPreview,

    81     EPluginPromptChanged,

    82     EPluginShowCandidate,

    83     EPluginShowTooltip,

    84     EPluginHideTooltip,

    85     EPluginSwitchToPortrait,

    86     EPluginSwitchToLandscape,

    87     EPluginSwitchMode,

    88     EPluginUpdatePenInputITIStatus,

    89 	EPluginEnableFetchDimState,

    90     EPluginArabicNumModeChanged,

    91 	EPluginEnablePriorityChangeOnOriChange

    92     };

    93 

    94 /** 

    95  * Plugin synchronization type

    96  */

    97 enum TPluginSync

    98     { 

    99     EPluginSyncCurSel,

   100     EPluginSyncUpdatedText,

   101     EPluginSyncAll

   102     };

   103     

   104 #ifdef RD_SCALABLE_UI_V2

   105 

   106 /**

   107  * CAknFepPluginManager class.

   108  *

   109  *  @lib AknFep.lib

   110  *  @since 2.8

   111  */

   112 class CAknFepPluginManager : 

   113     public CBase,

   114     public MAknFepPenSupportInterface,

   115     public MPeninputServerEventHandler,

   116     public MEikEdwinObserver

   117     { 

   118 public:

   119 	

   120 	/**

   121 	 * Simulate event mode

   122 	 * @remark: Used in SubmitUiPluginTextL()

   123 	 */	

   124 	enum TSimulateEventMode

   125 		{

   126 		EIgnor,

   127 		ERawEvent,

   128 		EKeyEvent	

   129 		};

   130 		

   131      /**

   132      * NewL first phase construction

   133      *

   134      * @param aFepMan fep manager

   135      *

   136      */

   137     static CAknFepPluginManager* NewL( CAknFepManager& aFepMan,

   138                                       CAknFepSharedDataInterface& aSharedData,

   139                                       CAknFepLanguageManager& aLangMan,

   140                                       CAknFepCaseManager& aCaseMan );

   141 

   142      /**

   143      * Destructor

   144      */

   145     virtual ~CAknFepPluginManager();

   146     

   147 private:

   148 

   149      /**

   150      * private constructor

   151      */

   152     CAknFepPluginManager( CAknFepManager& aFepMan,

   153                          CAknFepSharedDataInterface& aSharedData,

   154                          CAknFepLanguageManager& aLangMan,

   155                          CAknFepCaseManager& aCaseMan );     

   156     

   157      /**

   158      * Construct

   159      *

   160      * @param aFepMan fep manager

   161      *

   162      */

   163     void ConstructL();

   164 

   165 public :

   166      

   167     enum TSpellCBA

   168         {

   169         ESpellCBANone,

   170         ESpellCBACancelEmpty,

   171         ESpellCBAOkCancel,

   172         };

   173     

   174 public:

   175 

   176 // From MAknFepPenSupportInterface

   177     

   178     /**

   179      *  From MAknFepPenSupportInterface

   180      *  Activate pen input method

   181      *

   182      *  @since 3.2

   183      *  @Return None

   184      */

   185     void ActivatePenInputL();

   186 

   187     /**

   188      *  From MAknFepPenSupportInterface

   189      *  Deactivate pen input method

   190      *

   191      *  @since 3.2  

   192      *  @Return None

   193      */

   194     void DeactivatePenInputL();

   195 

   196 // From MPeninputServerEventHandler

   197         

   198     /**

   199      * From MPeninputServerEventHandler

   200      * Handle pen input server events.

   201      *

   202      * @since 3.2

   203      * @param aEventId Event to handle.

   204      * @return ETrue If server event handled

   205      */

   206     TBool HandleServerEventL(TInt aEventId);

   207     

   208     /**

   209      *  Handle events from FEP

   210      *  suggested mode.

   211      *  

   212      *  @since 3.2

   213      *  @param aEventType, event type from FEP

   214      *  @param aEventData, event data from FEP

   215      *  @return ETrue successful, EFalse otherwise

   216      */

   217     void HandleEventsFromFepL( TInt aEventType, TInt aEventData );

   218 

   219     /**

   220      *  Change current input method to plugin input method with

   221      *  suggested mode.

   222      *  

   223      *  @since 3.2

   224      *  @return ETrue successful, EFalse otherwise

   225      */

   226     TBool TryChangePluginInputModeByModeL(TPluginInputMode aSuggestMode, TInt aOpenMode, 

   227                                           TInt aSuggestRange);

   228     

   229     /**

   230      *  Close plugin input mode, reset iPluginInputMode

   231      *  to EPluginInputModeNone

   232      *

   233      *  @since 3.2

   234      *  @param aRestore, If ETrue, restor rembered HKB mode

   235      *  @return None

   236      */

   237     void ClosePluginInputModeL(TBool aRestore);

   238     

   239         /**

   240      *  Close plugin input UI, only close UI

   241      *

   242      *  @param aResetState If ETrue, reset UI state

   243      *  to initial.

   244      *  @return None.

   245      */

   246     void ClosePluginInputUiL(TBool aResetState);

   247        

   248     /**

   249      * Handle resource change.

   250      * 

   251      * @param aType The resource type

   252      * @return None.

   253      */

   254     void OnResourceChangedL(TInt aType);

   255          

   256     /**

   257      *  Synchronize plugin UI text with editor

   258      *

   259      *  @since 3.2

   260      *  @return None

   261      */

   262     void SyncFepAwareText( TPluginSync aSyncType = EPluginSyncCurSel, TBool aSendNow = ETrue );

   263 

   264     /**

   265      * Processes commands from the edit menu

   266      * 

   267      * @since 3.2

   268      * @param aCommandId The menu command id

   269      * @return None.

   270      */

   271     void ProcessMenuCommandL(TInt aCommandId);

   272 

   273     /**

   274      * Handle key events

   275      * 

   276      * @since 3.2

   277      * @param aCommandId The key id

   278      * @return None.

   279      */

   280     void HandleKeyEventL(TInt aKeyId);

   281     

   282     /**

   283      * initialize the edit menu depending on fep and editor state

   284      * 

   285      * @since 3.2

   286      * @param aMenuPane The pointer to menu pane

   287      * @return None.

   288      */

   289     void InitMenuPaneL( CAknEdwinState* aEditorState, 

   290         CAknFepUiInterfaceMenuPane* aMenuPane, TInt aResourceId );

   291     

   292     /**

   293      * Handles notifications that the UI has changed focus

   294      * 

   295      * @since 3.2

   296      * @param aFepFullyConstructed The flag of fep fully constructed

   297      * @return None.

   298      */

   299     void OnFocusChangedL( TBool aGainForeground );

   300 

   301             

   302     /**

   303      * Set ICF data

   304      *

   305      * @since 3.2

   306      * @param aTextChanged If editor text changed

   307      * @param aIcfData ICF data

   308      * @return None

   309      */

   310     void SendIcfDataL(  TPluginSync aSyncType = EPluginSyncCurSel );            

   311     /**

   312      * Set editor cursor selection according plugin UI 

   313      * cursor state

   314      *

   315      * @since 3.2

   316      * @param aCurSel Cursor position.

   317      * @param aSyncCursor ETrue if plug in UI need update cursor, EFalse otherwise

   318      * @return None

   319      */

   320     void SetCursorSelectionL(const TCursorSelection& aCurSel, TBool aSyncCursor);

   321     

   322     HBufC*  GetNumberKeymapResource(TInt aCaseMode);

   323     

   324     HBufC*  DoGetNumberKeymapResourceL(TInt aCaseMode);

   325     

   326     MAknFepManagerInterface* CurrentFepInputUI();

   327     

   328     void SetFingerMatchSelectionState(TBool aMatchStateOn);

   329     TBool IsVisible();

   330 

   331     // send all predictive candidates at once

   332     void ShowAllCandidates();

   333     

   334     void ResetCandidateList();

   335     

   336     void UpdateFSQIndicator();

   337     void UpdateITUTIndicator();

   338     

   339     void SetITUTSpellingStateL(TBool aState);

   340     

   341     void DisplaySpellEditor(const TInt aEditorFlag, const TDesC& aInitText, 

   342                             TCursorSelection aCurSel);

   343     void DisplaySpellEditorL(const TInt aEditorFlag, const TDesC& aInitText, 

   344                            TCursorSelection aCurSel);                            

   345     

   346     void HideSpellEditor();

   347     

   348     HBufC* SpellTextInput();

   349     void SetTCursorSelection();

   350     

   351     void HandleEdwinEventL(CEikEdwin* , TEdwinEvent aEventType);

   352     

   353     TInt GetSoftKeyResID();

   354     

   355     void HasNoFreeSpace();

   356 

   357     TBool EnterMatchSelectionState();

   358     

   359     TPluginInputMode PluginInputMode();

   360     

   361     void UpdateCaseMode();

   362     

   363     TBool IsGlobleNotes();

   364     TBool IsDimed();

   365     /**

   366      *  Save the cursor visibility. This function is called from fep side, 

   367      *  because of sync cursor visibility

   368      *

   369      *  @since v5.0

   370      */

   371     void SetCursorVisibility(TBool aVisibility, TBool aReportPlugin = EFalse);

   372     /**

   373      * Get the correct indicator for VKB;

   374      *

   375      * @return The correct indicator state for VKB.     

   376      */

   377     TAknEditingState VKBIndicatorState( TAknEditingState aOldState );

   378     void ClosePeninputSetting();

   379 

   380     /**

   381      * Show tooltip on FSQ to show the best guess word shown inline,

   382      * when it is necessary

   383      *

   384      * @param aText The tooltip text to be displayed

   385      * @return None

   386      */

   387     void ShowTooltipOnFSQL( TInt aSecondaryIdx );    

   388 

   389     /**

   390      * Hide tooltip on FSQ if necessary

   391      *

   392      * @return None

   393      */

   394      void HideTooltipOnFSQL();  

   395      

   396     /**

   397      * Open a candidate list to show contents in aItemArray

   398      *

   399      * @param aCandidateList ITI candidate data

   400      * @return None

   401      */

   402     void ShowCandidateListL( TFepITICandidateList aCandidateList );

   403     

   404     /**

   405      * Hide candidate list

   406      *

   407      */

   408     void HideCandidateListL();

   409 

   410     /**

   411      * Commit candidate word on FSQ

   412      * 

   413      * @param aIndex the index in candidate lists;

   414      * @return None

   415      */    

   416     void CommitCandidateWordOnFSQL( TInt aIndex );

   417     

   418     /**

   419      * Check if ITI features is enabled when FSQ is opened.

   420      */

   421     TBool EnableITIOnFSQ();

   422 

   423     /**

   424      * Check if ITI can be supported by FSQ.

   425      */

   426     TBool IsSupportITIOnFSQ();

   427     

   428     /**

   429      * Restore some configuration after closing FSQ.

   430      *     

   431      */

   432     void ResetItiStateL();    

   433 

   434 /*    

   435 #ifdef RD_TACTILE_FEEDBACK

   436     TBool VKBIsOpened();

   437 #endif // RD_TACTILE_FEEDBACK

   438 */

   439 

   440     void HandleiDimGainForeground(TBool aGain);

   441 

   442     void OnServerReady(TInt aErr);

   443     

   444     /**

   445      *  Remove last focused window,which launches touch input, from open list.

   446      *

   447      *  @since v5.0

   448      */

   449     void RemoveLastFocusedWinFromOpenList();

   450     

   451     /**

   452      * Set the editor pointer to NULL

   453      *

   454      * @since v5.0

   455      * @param none

   456      * @return void

   457      */

   458     void ClearDestroyedEditorPointer();

   459     

   460     /**

   461      * Get the editor state

   462      *

   463      * @since v5.0

   464      * @param none

   465      * @return the pointer of editor state

   466      */

   467     CAknEdwinState* EdwinState();

   468     

   469 public: // inline    

   470     

   471     /**

   472      * Get current plugin input UI

   473      *

   474      * @since 3.2

   475      * @return The pointer to MAknFepManagerInterface

   476      */      

   477     inline MAknFepManagerInterface* CurrentPluginInputFepUI();

   478     

   479     /**

   480      * Get current plugin input mode

   481      *

   482      * @since 3.2

   483      * @return current plugin input mode

   484      */      

   485     

   486     inline TBool PluginNativeRange();

   487     

   488     inline void SetPluginNativeRange( TBool aPluginNativeRange );

   489     

   490     inline TBool SyncWithPluginRange();

   491     

   492     inline RPointerArray<HBufC>& MatchCandidateList();    

   493 

   494     inline TBool IsMatchState();  

   495     

   496     inline TBool IsSpellVisible();

   497     

   498     inline void SetCursorSelection(TCursorSelection& aCursorSel); 

   499     

   500     inline TCursorSelection CursorSelection(); 

   501     

   502     inline void SetCaseUpdatesSupressed(TBool aCaseUpdatesSupressed);

   503     inline TBool CaseUpdatesSupressed();

   504     

   505     inline void SetBeforeSpell(TBool aBeforeSpell);

   506     inline TBool BeforeSpell();

   507     inline HBufC* GetSpellText();

   508     inline void SpellText(HBufC* aSpellText);

   509     inline TBool IsNonLatinLanguage(TLanguage aLang);

   510     inline TInt PreviousPermitMode();

   511     /**

   512      *  In T9 predictive text input, if user press "Spell" button, a edit word query dialog is opened.  

   513      *  This Flag is set for this case to indicate whether edit wod query dialog is opened.

   514      *  @param aIsEditWordQueryDlg  ETrue means dialog is open,

   515                                     EFalse means dialog is not open.

   516      *  @since v5.0

   517      */    

   518     inline void SetInEditWordQueryFlag(TBool aIsEditWordQueryDlg );    

   519     void LaunchPenInputLanguageSelectionL( TBool aLaunchedByTouchWin = EFalse );

   520     void LaunchPenInputRecognitionWithDictionarySelectionL();

   521     void LaunchPenInputWritingSpeedSelectionL();

   522     void LaunchPenInputGuidingLineSelectionL();

   523   inline TBool IsInGlobleNoteEditor();

   524     void SetMenuState(TBool aUpdateEditor = ETrue);

   525     void ResetMenuState(TBool aUnDim = ETrue);

   526     

   527     /**

   528      * When ITI setting opened, set this flag to ETrue

   529      *  

   530      * @param aOpen  ETrue means dialog is open,

   531      *               EFalse means dialog is not open.

   532      * @return None  

   533      */    

   534     inline void ITISettingDialogOpen( TBool aOpen );

   535     

   536     /**

   537      * Check if tooltip box on FSQ is opened.

   538      *

   539      * @return if ETrue: Tooltip box on FSQ is enabled.

   540      */    

   541     inline TBool IsTooltipOpenOnFSQ();

   542     

   543     /**

   544      * Get whether inMenu has been opened.

   545      * InMenu is that any pop-up dialog, e.g. menu, SCT, is launched by fep.

   546      * 

   547      * @since 5.0

   548      * @return whether inMenu has been opened

   549      */     

   550     inline TBool IsInMenuOpen();

   551     

   552     /**

   553      * Get current plugin input mode even if current window is close.

   554      * The function is defferent from PluginInputMode(), PluginInputMode() 

   555      * return EPluginInputModeNone if current input window is closed

   556      * 

   557      * @since 5.0

   558      * @return current plugin input mode

   559      */      

   560     inline TPluginInputMode CurrentPluginInputMode();

   561     

   562     inline void SetLaunchSCTInSpell( TBool aLaunchSCTInSpell );

   563 private: 

   564 

   565     /**

   566      *  Initialize plugin UI, set permitted ranges, primary

   567      *  range, case mode and etc.

   568      *  

   569      *  @since 3.2

   570      *  @Return None

   571      */

   572     void InitializePluginInputL(TInt aOpenMode, TInt aSuggestRange, TBool aCleanContent);

   573 

   574     /**

   575      * Launch plugin menu

   576      *

   577      * @since 3.2

   578      * @param aResource Menu resource id.

   579      * @return None

   580      */

   581     void LaunchPenInputMenuL(TInt aResourceId, TBool aRemeber = ETrue);

   582         

   583     /**

   584      *  Show pen input language setting of general setting view

   585      *

   586      *  @since 3.2

   587      *  @return None

   588      */

   589         

   590     /**

   591 	 *  Show pen input setting of general setting view

   592      *  @since 3.2

   593      *  @param aData Key data

   594      *  @return None

   595      */

   596     void LaunchPenInputSettingL();

   597        

   598     /**

   599      * Parse editor text passed to plugin ICF

   600      * Only return current paragraph of current cursor position.

   601      *

   602      *  @since 3.2

   603      *  @param aBuffer Editor text

   604      *  @param aCurrent Current cursor position.

   605      *  @param aFrom Returned paragraph start pos.

   606      *  @param aTo Returned paragraph end pos.

   607      *  @return None

   608      */

   609     void ParseInputContextContent(TDes& aBuffer, TInt aCurrent, 

   610                                   TInt& aFrom, TInt& aTo);

   611     

   612                                       

   613     /**

   614      *  Submit text input from plugin UI to editor

   615      *

   616      *  @since 3.2

   617      *  @param aData Key data

   618      *  @param aForcedMode Forced simluate event mode.

   619      *  @return None

   620      */

   621     void SubmitUiPluginTextL(const TDesC& aData, 

   622     						 TSimulateEventMode aForcedMode = EIgnor);

   623 

   624     /**

   625      *  Handle key event sent from pen input server

   626      *

   627      *  @since 3.2

   628      *  @param aData Key data

   629      *  @return None

   630      */

   631     void OnPenInputServerKeyEventL(const TDesC& aData);   

   632     

   633     /**

   634      *  Sync indicator with plugin range

   635      *  

   636      *  @since 3.2

   637      *  @Return None

   638      */

   639     void SyncIndicatorWithPluginRangeL();

   640      

   641     /**

   642      *  Get current suggest mode

   643      *  

   644      *  @since 3.2

   645      *  @param aSuggestMode The mode suggested

   646      *  @Return None

   647      */    

   648     TBool GetCurSuggestMode( TPluginInputMode& aSuggestMode );

   649     

   650     /**

   651      *  Connect server

   652      *  

   653      *  @since 3.2

   654      *  @Return ETrue If connection sucess

   655      */

   656     TBool ConnectServer();

   657     

   658     /**

   659      *  Notify layout

   660      *  

   661      *  @since 3.2

   662      *  @param aOpenMode The current input mode

   663      *  @param aSuggestRange The suggest range

   664      *  @Return None

   665      */

   666     void NotifyLayoutL(TInt aOpenMode, TInt aSuggestRange, TBool aCleanContent);

   667     

   668     /**

   669      *  verify if mode switch button enable

   670      *  

   671      *  @since 3.2

   672      *  @Return ETrue if mode switch button enable

   673      */

   674     TBool IsEnableModeSwitchBtn();

   675     

   676     /**

   677      *  verify if setting buttons enable

   678      *  

   679      *  @since 3.2

   680      *  @Return ETrue if setting buttons enable

   681      */

   682     TBool IsEnableSettingBtn();

   683     

   684     /**

   685      *  Notify layout the editor's keymapping

   686      *  

   687      *  @since 3.2

   688      *  @Return None

   689      */

   690     void NotifyLayoutKeymappingL();

   691              

   692     /**

   693 	 *  Test data query show status

   694      *  @since 3.2

   695      *  

   696      *  @return ETrue if data query is showing now, EFalse otherwise

   697      */

   698     TBool IsDisplayDataQuery();

   699     

   700     /**

   701 	 *  Show pen input setting of general setting view

   702 	 *

   703      *  @since 3.2

   704      *  @param aForce ETrue means adjusting data query no matter current showing status,

   705                       EFalse means adjusting data query window only first time

   706      *  @return None

   707      */

   708     void RepositionDataQuery(TBool aForce);

   709     

   710     /**

   711      * Timer procedure for adjust data query position

   712      *

   713      * @param aPtr The pointer of CAknFepManager itself

   714      * @since 3.2

   715      * @return 0.(meaningless)

   716      */

   717     static TInt AdjustDataQueryCallBackL(TAny *aPtr);

   718     

   719     

   720     static void FepObserverHandleCompletionOfTransactionL(MCoeFepObserver& aFepObserver);

   721     

   722     void CreateFingerItutChineseUiL();

   723 

   724     /**

   725      * Launch Hwr Training UI

   726      * 

   727      * @since 3.2

   728      * @return None

   729      */

   730     void LaunchHwrTrainUiL();

   731     

   732     TBool GetIndicatorImgID(const TInt IndicatorUID,TInt &aImage, TInt &aMask);

   733     TBool GetIndicatorImgIDL(const TInt IndicatorUID,TInt &aImage, TInt &aMask);

   734     

   735     void SetPromptText( TBool aCleanContent = ETrue );

   736     

   737     void SetIcfAlignment();

   738     

   739     void ConvertDigitToDigittype(TDigitType& digittype,TDes& aConvertedNumeral);

   740 

   741     void GetAllPredictiveCandidate();

   742     void GetAllPredictiveCandidateL();

   743     

   744     void AddCurrentWinToOpenListL();

   745     

   746     void AddWinToOpenListL( RDrawableWindow* aWin);

   747     

   748     void RemoveCurrentWinFromOpenList();

   749     

   750     TBool IsCurrentWindInOpenList();

   751     

   752     TBool ExistInlineText();

   753     

   754     TBool SetSyncCurSelIcfDataL( TFepInputContextFieldData& aIcfData );

   755     

   756     TBool SetSyncIcfDataL( TFepInputContextFieldData& aIcfData, 

   757                           const TDesC& aLastEditorContent,

   758                           const TDesC& aCurrentEditorContent );

   759                           

   760     TBool TextInlined( const TDesC& aLastEditorContent, const TDesC& aCurrentEditorContent);

   761     

   762     TBool TextInserted( const TDesC& aLastEditorContent, const TDesC& aCurrentEditorContent);

   763                                           

   764     TBool TextDeleted( const TDesC& aLastEditorContent, const TDesC& aCurrentEditorContent);

   765 

   766     TBool TextMultiTapped( const TDesC& aLastEditorContent, const TDesC& aCurrentEditorContent);

   767 

   768 	void AdjustDataCase( TDes& aData );

   769 	

   770 	TBool IsDimArrowKeys();

   771 	

   772 	void LaunchHelpL();

   773 	void DimAllModeAndCase(CAknFepUiInterfaceMenuPane* aMenuPane);

   774 	

   775 	TInt RepeatStringFromLeft(const TDesC& aSubmitData, TDes& aEditorData);

   776 

   777     void InformMfneUiStatusL( TBool aOpened );

   778     

   779     /** 

   780      * Update editor state according to current ui state

   781      * 

   782      * @since Symbian^3 

   783      * @param aOpened specifies current ui is opened or closed

   784      */

   785     void SetEdwinFlagsByUiStatus( TBool aOpened );

   786     

   787     /** 

   788      * Update state flags of specified editor

   789      * 

   790      * @since Symbian^3 

   791      * @param aEdwin  specifies the editor to be updated

   792      * @param aFlags  editor state flags

   793      * @param aSet    ETrue to add flags, or EFalse to remove flags.

   794      */

   795     void SetAknEdwinFlags( MCoeFepAwareTextEditor* aEdwin, TInt aFlags, TBool aSet );

   796     

   797     void UpdatePredicState();

   798                             

   799     TBool NotifyInGlobalNoteEditorL();

   800 

   801     TBool IsChineseIndicator( TAknEditingState aOldState );

   802     

   803     TBool IsEditorCursorDisabled();

   804 

   805     /**

   806      * Check if the cusror in editor is visible.

   807      *

   808      * @return ETrue: the cursos in editor is visible.

   809      *         EFalse: the cursos in editor is invisible.

   810      */

   811     TBool IsEditorCursorVisible();

   812     

   813 

   814     /**

   815      * Check if curor selection in editor is visible.

   816      *

   817      * @return ETrue: the cursos in editor is visible.

   818      *         EFalse: the cursos in editor is invisible.

   819      */    

   820     TBool IsEditorCursorSelVisible();

   821        

   822     /**

   823      * Get scan code from hw keymapping.

   824      *

   825      * @param aKeyCode unicode of each virutal key text.

   826      */

   827     TInt GetScanCodeFromHwKeymapping( TUint aKeyCode );

   828     

   829     /**

   830      * Check if those keys are IIT-supported keys

   831      *

   832      * @param aKeyEvent The keys to be checked.

   833      */

   834     TBool IsITISupportedKey( const TKeyEvent& aKeyEvent );

   835     

   836     TPtiTextCase CaseForMappedCharacter(TChar aCharacter);

   837     

   838     TBool IsNeedToChangeTextCase( const TPtiTextCase& aTextCase );

   839     

   840     /**

   841      * Do some configuration to make FSQ support ITI features

   842      *     

   843      */

   844     void SetItiStateL();

   845     

   846     /**

   847       * Config keyboard layout for ITI

   848       *     

   849       */

   850     void SetItiKeyboardLayoutL();

   851 

   852     /**

   853      * Restore keyboard layout after closing FSQ.

   854      */

   855     void ResetItiKeyboardLayoutL();

   856     

   857     /**

   858      * Restore predict state.

   859      */

   860     void RestorePredictStateL();

   861     

   862     /**

   863      * Check if the keycode belongs to dead keys.

   864      *     

   865      * @param aKeyCode: key code to be checked

   866      * @return ETrue: belongs to ETrue

   867      *         EFalse: doesn't belong to EFalse;

   868      */

   869     TBool IsDeadKeyCode( TUint aKeyCode );

   870     

   871     /**

   872      * Notify app touch window state.

   873      *     

   874      * @param aParam

   875      * @return None

   876      */

   877     void NotifyAppUiImeTouchWndStateL( const TBool aTouchState );

   878         

   879     /**

   880      * Check if current editor support partial screen IMEs

   881      * 

   882      * @return ETrue if support  

   883      */

   884     TBool IsEditorSupportSplitIme();

   885     

   886     void SetICFTextForSpellL();

   887     

   888     void SendMatchListCmd(const RArray<TPtrC>& aList);

   889 	/**

   890 	 * Initialize the Menu item in Option Menu for Arabic Finger HWR

   891 	 *

   892 	 * @CAknFepUiInterfaceMenuPane* aMenuPane The menu pane used to add more menu items

   893 	 */

   894 	void InitMenuItemForArabicFingerHwrL(CAknFepUiInterfaceMenuPane* aMenuPane);

   895 

   896     /**

   897      * andling the menu cmd for changing the input mode

   898      *     

   899      * @param aInputMode: the inputmode should be activate

   900      * @return None

   901      */

   902     void ProcessChangingInputModeCmdL(TInt aInputMode);

   903 	

   904 private:    // Data

   905     

   906     /**

   907      * The reference of fep manager

   908      */

   909     CAknFepManager& iFepMan;

   910     

   911     /**

   912      * The reference of language manager

   913      */

   914     CAknFepLanguageManager& iLangMan;

   915     

   916     /**

   917      * The reference of case manager

   918      */

   919     CAknFepCaseManager& iCaseMan;

   920     

   921     /**

   922      * The reference of shared data manager

   923      */

   924     CAknFepSharedDataInterface& iSharedData;

   925 

   926 

   927     /**

   928      * Current plugin UI interface

   929      */

   930     MAknFepManagerInterface* iCurrentPluginInputFepUI;

   931 

   932     /**

   933      * Current plugin input mode

   934      */

   935     TPluginInputMode iPluginInputMode;

   936     

   937     /**

   938      * Current plugin primary range

   939      */

   940     TInt iPluginPrimaryRange;

   941 

   942     /**

   943      * Update editor cursor timer

   944      */

   945     CPeriodic* iAdjustDataQueryTimer;

   946     

   947     /**

   948      * HKB predictive state before starting plugin IME

   949      */

   950     TBool iT9UsedBeforePluginInput;

   951     

   952     /**

   953      * Indicating connection state to pen input server

   954      */

   955     TBool iAutoCompBeforePluginInput;

   956     /**

   957      * Indicating connection state to pen input server

   958      */

   959     TBool iPenInputSvrConnected;

   960     

   961     /**

   962      * flags of layout UI submit status

   963      */

   964     TInt iLastSubmitCount;

   965     

   966     /**

   967      * Data query showing status

   968      */

   969     TBool iDataQueryAlreadyShow;

   970     

   971     /**

   972      * Plugin menu manager object

   973      */

   974     CAknFepPluginMenuManager* iPenInputMenu;

   975 

   976     /**

   977      * Pen input server handle

   978      */

   979     RPeninputServer iPenInputServer;

   980     

   981     /**

   982      * flags of language has been changed by setting

   983      */

   984     TInt iCurLanguage;

   985     

   986     /**

   987      * flags of fast swap by menu

   988      */

   989     TBool iFastSwapByMenu;

   990     

   991     MAknFepManagerInterface* iFingerItutChineseUI;

   992     

   993     TCursorSelection iCurSelPre;

   994     

   995     TCursorSelection iCurSelCur;

   996     

   997     TPluginSync iSyncType;

   998     

   999     HBufC* iIcfDataBuf;

  1000     

  1001     RPointerArray<HBufC> iCandidateList;

  1002     TInt iCandidateIndex;

  1003 

  1004     TFepInputAllCandidates iSendAllList;

  1005     

  1006     TBool iMatchState; 

  1007     

  1008     TInt iIndicatorImgID;

  1009     CAknFepUiSpellContainer* iSpell;

  1010     

  1011     TBool iSpellOn; 

  1012     

  1013     TCursorSelection iCursorSel;

  1014 

  1015     TInt iIndicatorTextID;

  1016     

  1017     TBool iCaseUpdatesSupressed;

  1018     

  1019     TBool iBeforeSpell;

  1020     

  1021     HBufC* iSpellText;

  1022     

  1023     TSpellCBA iSpellCba;

  1024     TBool iPenUiDimmed;

  1025     TBool iIsForeground;

  1026     

  1027     TInt iPreDocumentLengthForFep;

  1028     TInt iOpenPenUiFlag;

  1029     

  1030     TBool iPluginNativeRange;

  1031     

  1032     TBool iSyncWithPluginRange;

  1033     

  1034     RArray<TInt> iOpenWindowList;

  1035     TInt         iLastFocusedWin;

  1036     

  1037     HBufC* iLastEditorContentBuf;

  1038     

  1039     TBool iModeChanged;

  1040     

  1041     TInt iPreviousCoseMode;

  1042     

  1043     TBool iLaunchMenu;

  1044     TBool iInMenu; // need to check whether it can be replaced by iLaunchMenu

  1045     TUint iCurMFNECap;

  1046     MCoeFepAwareTextEditor* iCurEditor;

  1047     MCoeFepAwareTextEditor* iOldFepAwareEditor;

  1048 

  1049     RDrawableWindow *    iLastDataQueryWin;

  1050     

  1051     TInt iDefaultOrientation;

  1052     RBuf iEventData;

  1053     TBool iDisableSyncText;

  1054     TBool iPendingSyncReq;

  1055     TBool iHasSWEventCap;

  1056     TInt iCurPermitModes;

  1057     TBool isLanuchSCT;

  1058     TBool iInGlobleNoteEditor;

  1059     TBool iOrientationChanged;

  1060     TBool iInlineStateOn;

  1061     TInt iCharStartPostion;

  1062     /**

  1063      * Cursor Visibility

  1064      */

  1065     TInt iEditorPriority;

  1066     TBool iDimGainForeground;

  1067     TBool iEnableIndicatorBtn;

  1068     TBool iEnableSettingBtn;

  1069     TBool iEnableArrowBtn;

  1070     TBool iCursorVisibility;

  1071     TBool iForegroundChange;

  1072     TBool iResourceChange;

  1073 

  1074     TBool iLaunchHelp;

  1075     TInt iCurPermittedModes;

  1076     MCoeFepAwareTextEditor* iMfne;

  1077     

  1078     /**

  1079      * current focused editor

  1080      * not own 

  1081      */

  1082     MCoeFepAwareTextEditor* iEdwin;

  1083     

  1084     TBool iMfneChanged;

  1085     TBool iIsInEditWordQueryDlg;

  1086     

  1087 	TBool iPreferredUiMode;

  1088 

  1089     CRepository* iAvkonRepository;

  1090     

  1091     TBool iClosePluginInputMode;

  1092 	

  1093 	TBool iOrientationChangedfromUI;

  1094 	

  1095 	CPenInputGSInterface* iGsInterface;

  1096     RBuf iPreCaption;

  1097     TBool iIsPassWord;

  1098 

  1099     /**

  1100      * Store the last keyboard layout.

  1101      */

  1102     TInt iLastKeyboardLayout;

  1103     

  1104 

  1105     /**

  1106      * Indicate if predictive setting dialog opened.

  1107      */

  1108     TBool iITISettingDialogOpen;

  1109     

  1110     /**

  1111      * Indicate if current input mode is qwerty mode.

  1112      */

  1113     TBool iIsITIConfigured;

  1114     

  1115     /**

  1116      * Indicate if tooltip on FSQ is opened

  1117      */       

  1118     TBool iTooltipOpenOnFSQ;    

  1119 	

  1120 	TInt iAlignment;

  1121 

  1122     CConnectAo* iConnectAo;    

  1123 	

  1124     /**

  1125      * Indicate if need fetch the dim state from peninputserver

  1126      */ 	

  1127 	TBool iNeedFetchDimState;

  1128 

  1129     /**

  1130      * save the current dim state

  1131      */ 	

  1132     TBool iCurrentDimState;

  1133     

  1134     TBool iLaunchSCTInSpell;