1 /*

     2 * Copyright (c) 2002 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 // System includes

    30 #include <aknedsts.h> 

    31 #include <AknUtils.h> 

    32 #include <aknappui.h> 

    33 #include <eikccpu.h> 

    34 #include <eikdialg.h> 

    35 #include <eikcapc.h> // CEikCaptionedControl

    36 #include <aknQueryControl.h> 

    37 #include <centralrepository.h> 

    38 #include <StringLoader.h> 

    39 #include <AknFepPluginManager.h>

    40 #include <aknfeppeninputimeplugin.h>

    41 #include <UikonInternalPSKeys.h> // KUikGlobalNotesAllowed

    42 #include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

    43 #include <hlplch.h>

    44 //#include <peninputgsinterface.h>

    45 #include <aknfep.rsg>

    46 #include <avkon.rsg>

    47 #include <AknIndicatorContainer.h>  //CAknIndicatorContainer

    48 #include <StringLoader.h>

    49 #include <peninputgenericitutcustomization.h>

    50 #include <eikgted.h> 

    51 #include <txtglobl.h>

    52 #include <eikedwin.h> 

    53 #include <featmgr.h>                 //FeatureManager

    54 #include <aknextendedinputcapabilities.h>

    55 #include <avkon.hrh>

    56 #include <PtiEngine.h>

    57 //#include <peninputcommonlayoutglobalenum.h>

    58 #include <PtiCompositionDataIF.h> // MPtiEngineCompositionDataInterface

    59 #include <eikapp.h>

    60 #include <AknFepGlobalEnums.h>

    61 #include <AknFepInternalCRKeys.h>

    62 

    63 // User includes

    64 #include "AknFepManagerInterface.h" // MAknFepManagerInterface

    65 #include "AknFepUiManagerBase.h"

    66 #include "aknfepuimanagerfingeritutchinese.h"

    67 

    68 // For Spell

    69 #include "aknfepuispellcontainer.h"            

    70 #include "aknfepuispellinputpane.h"

    71 

    72 #include <eikgted.h> 

    73 

    74 #include <apgwgnam.h>

    75 

    76 #include <PtiKeyMappings.h>

    77 #include <AknPriv.hrh>

    78 

    79 // Constants

    80 const TInt KCursorBlinkPerioid = 10000;//300000; // five tenth of a second * 2

    81 const TInt KMaxServerDataLength = 50;

    82 const TUint KVkbParagraphSeparator = 0x2029;

    83 const TUint KVkbTabulator = 0x0009;

    84 const TUid KAknfepUID= { 0x100056de }; 

    85 const TUid KUidtruiApp = { 0x2000B104 }; 

    86 const TInt KAknScreenServerUid = 0x100056cf;

    87 const TInt KAknCapServerUid = 0x10207218;

    88 const TInt KAknNotifySrvUid = 0x10281EF2;

    89 const TInt KAknHelpAppUid = 0x10005234;

    90 const TInt KInvalidValue = -1;

    91 

    92 // Paste event for AknCcpuSupport

    93 const TKeyEvent KAknCcpuPasteEvent = {EKeyF18, EEikCmdEditPaste, EModifierCtrl, 1}; 

    94 

    95 const TUint KSupportedDeadKeys[] = { 0x005E, 0x0060, 0x00A8, 0x007E, 0x00AF, 

    96 		                             0x00B4, 0x00B8, 0x02C7, 0x02DB, 0x02DD, 

    97 		                             0x00A8, 0x0384, 0x0385 }; 

    98 

    99 _LIT(KVkbTabChar, " ");

   100 

   101 _LIT(KHWR_HLP_MAIN_VIEW, "HWR_HLP_MAIN_VIEW");

   102 _LIT(KVQWERTY_HLP_MAIN_VIEW, "VQWERTY_HLP_MAIN_VIEW"); 

   103 _LIT(KVITU_HLP_MAIN_VIEW, "VITU_HLP_MAIN_VIEW");

   104 

   105 const TInt KDefaultCandidateArraySize = 16;

   106 const TInt KNumberOfCases = 6;

   107 

   108 #define iAvkonAppUi ((CAknAppUi*)CEikonEnv::Static()->EikAppUi())

   109 TUid AppUidFromWndGroupIdL(TInt aWndGrpId)

   110     {

   111     RWsSession &ws = CCoeEnv::Static()->WsSession();

   112     //TInt wgId =ws.GetFocusWindowGroup();

   113     CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(ws,aWndGrpId);

   114 

   115     TUid id = wg->AppUid();

   116     CleanupStack::PopAndDestroy(wg);    	

   117     return id;

   118     

   119     }

   120 

   121 TUid GetFocusAppUid()

   122     { 

   123     TUid id = {0x0};

   124     TRAP_IGNORE(id = AppUidFromWndGroupIdL(CCoeEnv::Static()->WsSession().GetFocusWindowGroup()));

   125     return id;

   126     }

   127 TUid GetCurAppUid()

   128     {

   129     TUid id = {0x0};	

   130     TRAP_IGNORE(id = AppUidFromWndGroupIdL(CCoeEnv::Static()->RootWin().Identifier())); 

   131     return id;           

   132     }

   133 

   134 TBool IsGlobalNotesApp(TUid& aUid)		  

   135     {

   136     const TInt KAknCapServerUid = 0x10207218;

   137     const TInt KAknNotifySrvUid = 0x10281EF2;      

   138     if(aUid.iUid == KAknCapServerUid || aUid.iUid == KAknNotifySrvUid)

   139         return ETrue;

   140     return EFalse;

   141     }

   142 #ifdef RD_SCALABLE_UI_V2

   143 inline TBool IsAbleTouseCallBubble()

   144     {

   145     const TInt KAknCapServerUid = 0x10207218;    

   146     return GetCurAppUid().iUid != KAknCapServerUid;

   147     }

   148 #endif //RD_SCALABLE_UI_V2

   149     

   150 RDrawableWindow* GetFocusWindow()

   151     {

   152     CCoeControl* focusControl = CCoeEnv::Static()->AppUi()->TopFocusedControl();

   153     if( focusControl )

   154         {

   155         return focusControl->DrawableWindow();

   156         }

   157     return NULL;

   158     }

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

   160 

   161 // ---------------------------------------------------------------------------

   162 // CAknFepPluginManager::NewL

   163 // (other items were commented in a header)

   164 // ---------------------------------------------------------------------------

   165 //    

   166 CAknFepPluginManager* CAknFepPluginManager::NewL( CAknFepManager& aFepMan,

   167                                                 CAknFepSharedDataInterface& aSharedData,

   168                                                 CAknFepLanguageManager& aLangMan,

   169                                                 CAknFepCaseManager& aCaseMan )

   170     { 

   171     CAknFepPluginManager* self = new (ELeave) CAknFepPluginManager

   172         ( aFepMan, aSharedData, aLangMan, aCaseMan ); 

   173     CleanupStack::PushL( self );

   174     self->ConstructL();       

   175     CleanupStack::Pop(self);

   176     return self;

   177     }

   178 

   179 // ---------------------------------------------------------------------------

   180 // CAknFepPluginManager::~CAknFepPluginManager

   181 // (other items were commented in a header)

   182 // ---------------------------------------------------------------------------

   183 //     

   184 CAknFepPluginManager::~CAknFepPluginManager()

   185     {  

   186     delete iAdjustDataQueryTimer;

   187 

   188     iCurrentPluginInputFepUI = NULL; // why not delete????

   189     delete iPenInputMenu;

   190     

   191     if( iPenInputSvrConnected )

   192         {

   193         iPenInputServer.Close();

   194         iPenInputSvrConnected = EFalse;

   195         }

   196     delete iFingerItutChineseUI;

   197     

   198     delete iIcfDataBuf;

   199     iIcfDataBuf = NULL;

   200     

   201     delete iSpellText;

   202     iSpellText = NULL;

   203 

   204     delete iSpell;

   205     iSpell = NULL;

   206     

   207     delete iLastEditorContentBuf;

   208     

   209     delete iAvkonRepository;

   210     

   211     /*    

   212     for(TInt i = 0; i < iCandidateList.Count(); i++)

   213         {

   214         HBufC* buf = iCandidateList[i];

   215         delete buf;

   216         }

   217     iCandidateList.Close();

   218     */

   219     iCandidateList.ResetAndDestroy();

   220     iSendAllList.iCandidates.Reset();

   221     iOpenWindowList.Close();

   222     iEventData.Close();    

   223     iPreCaption.Close();

   224     

   225 	  ClosePeninputSetting();

   226     }

   227     

   228 // ---------------------------------------------------------------------------

   229 // CAknFepPluginManager::CAknFepPluginManager

   230 // (other items were commented in a header)

   231 // ---------------------------------------------------------------------------

   232 // 

   233 CAknFepPluginManager::CAknFepPluginManager( CAknFepManager& aFepMan, 

   234                                           CAknFepSharedDataInterface& aSharedData,

   235                                           CAknFepLanguageManager& aLangMan,

   236                                           CAknFepCaseManager& aCaseMan )

   237     : iFepMan( aFepMan ), iLangMan( aLangMan ), iCaseMan( aCaseMan ),

   238       iSharedData( aSharedData ), iPluginPrimaryRange( ERangeInvalid ), iCandidateIndex(1),

   239       iCharStartPostion( KInvalidValue )

   240     {

   241     iIndicatorImgID = 0;

   242     iIndicatorTextID = 0;

   243     iLastDataQueryWin = NULL;

   244     iDefaultOrientation = -1;

   245     iIsInEditWordQueryDlg = EFalse;    

   246     iClosePluginInputMode = EFalse;

   247     iDimGainForeground = ETrue;

   248 	// Modify for bug ELZG-7WZC35 begin

   249     iAlignment = 0;

   250     // Modify for bug ELZG-7WZC35 end

   251     }

   252 

   253 // ---------------------------------------------------------------------------

   254 // CAknFepPluginManager::ConstructL

   255 // (other items were commented in a header)

   256 // ---------------------------------------------------------------------------

   257 // 

   258 void CAknFepPluginManager::ConstructL()

   259     {

   260     iPenInputMenu = CAknFepPluginMenuManager::NewL(&iFepMan);

   261     

   262     //here ERangeInvalid means there is no change of plugin input range.

   263     iFepMan.UiInterface()->TouchPaneSetFepPenSupportInterface(this);

   264     iEventData.CreateMaxL(KMaxServerDataLength);

   265     

   266     RThread client;

   267     iHasSWEventCap = client.HasCapability(ECapabilitySwEvent);

   268     client.Close();

   269     iAvkonRepository = CRepository::NewL( KCRUidAvkon ); 

   270     }

   271 

   272 // -----------------------------------------------------------------------------

   273 // CAknFepPluginManager::ActivatePenInputL

   274 // Change to default plugin input mode

   275 // (other items were commented in a header).

   276 // -----------------------------------------------------------------------------

   277 //

   278 void CAknFepPluginManager::ActivatePenInputL()

   279     {

   280     if( !iPenInputSvrConnected || !iPenInputServer.IsVisible() || iPenInputServer.IsDimmed() )

   281         {

   282         if( iFepMan.FepAwareTextEditor() )

   283             {

   284 			iPreferredUiMode = ETrue;

   285             TryChangePluginInputModeByModeL((TPluginInputMode)(iSharedData.PluginInputMode()),

   286                                             EPenInputOpenManually,

   287                                             ERangeInvalid);

   288             }

   289         }    

   290     iFepMan.PtiEngine()->CancelTimerActivity();    

   291     }

   292 

   293 // ---------------------------------------------------------------------------

   294 // CAknFepPluginManager::DeactivatePenInputL

   295 // (other items were commented in a header)

   296 // ---------------------------------------------------------------------------

   297 // 

   298 void CAknFepPluginManager::DeactivatePenInputL()

   299     {

   300     ClosePluginInputModeL(ETrue);

   301     }

   302 

   303 // -----------------------------------------------------------------------------

   304 // CAknFepPluginManager::HandleServerEventL

   305 // Handle pen input server events.

   306 // (other items were commented in a header).

   307 // -----------------------------------------------------------------------------

   308 //

   309 TBool CAknFepPluginManager::HandleServerEventL(TInt aEventId)

   310     {

   311     if(ESignalServerExit == aEventId)

   312         {

   313         iPenInputSvrConnected = EFalse; 

   314         return ETrue;

   315         }

   316     if(ESignalServerReady == aEventId)

   317         {

   318         //reconnect to server

   319         iFepMan.SendEventsToPluginManL(EPluginEditorActivate);

   320         return ETrue;

   321         }

   322     TBool bHandled = EFalse;

   323     if( !iLangMan.CurrentImePlugin())

   324         {

   325         return bHandled;

   326         }

   327     

   328     iEventData.Zero();

   329     TPtrC pBuf; 

   330     TInt dataLen = iPenInputServer.GetServerEventData(iEventData);

   331     

   332     if( KErrNone == dataLen )

   333         {

   334         pBuf.Set(iEventData);

   335         }

   336     else if ( dataLen > 0 )

   337         {

   338         iEventData.ReAllocL(dataLen);

   339         dataLen = iPenInputServer.GetServerEventData(iEventData);

   340         pBuf.Set(iEventData);

   341         }

   342     if( dataLen != KErrNone )

   343 	    {

   344 	    return ETrue;

   345 	    }

   346 

   347     if( !iLangMan.CurrentImePlugin()->HandleServerEventL(aEventId, iEventData) )

   348         {

   349         bHandled = ETrue;

   350         

   351         //only handle events which IME plug-in don't handled

   352         switch( aEventId )

   353             {

   354             case ESignalReplacePartText:

   355             case ESignalReplaceText://Get key event

   356             case ESignalReplaceTextJp:

   357                 {

   358                 TInt repeatCount = 0;

   359                 TInt len = *(TInt*)pBuf.Ptr();

   360                 TInt stringLength = pBuf.Length();

   361                 TInt midLength = sizeof(TInt)/sizeof(TText);

   362                 

   363                 if (midLength > stringLength)

   364                     {

   365                     break;   

   366                     }

   367 

   368                 iFepMan.SetFlag( CAknFepManager::EFlagSupressAutoUpdate );

   369 

   370                 TPtrC s = pBuf.Mid(midLength);//sizeof(TInt)/sizeof(TText)

   371                                 

   372                 //set selection

   373                 MCoeFepAwareTextEditor* edit = iFepMan.FepAwareTextEditor();

   374                 if( iFepMan.IsFepAwareTextEditor() && edit )

   375                     {

   376                     TCursorSelection curSor;

   377                     edit->GetCursorSelectionForFep(curSor);

   378                     if ( curSor.iAnchorPos == curSor.iCursorPos )

   379                         {

   380                         if (ESignalReplaceTextJp == aEventId)

   381                             {

   382                             if (curSor.iCursorPos  >= len)

   383                                 {

   384                                 curSor.iAnchorPos = curSor.iCursorPos - len;

   385                                 if (curSor.iAnchorPos<0 || 

   386                                     curSor.iAnchorPos>edit->DocumentLengthForFep())

   387                                     {

   388                                     break;

   389                                     }

   390                                 }

   391                             }

   392                         else

   393                             {

   394                             if(ESignalReplacePartText == aEventId)

   395                                 {

   396                                 curSor.iAnchorPos = curSor.iCursorPos - len;

   397                                 }

   398                             else

   399                                 {

   400                                 if ( iCharStartPostion == KInvalidValue )    

   401                                     {

   402                                     curSor.iAnchorPos = curSor.iCursorPos -  

   403                                         ( iLastSubmitCount<len?iLastSubmitCount:len );

   404                                     }

   405                                 else

   406                                     {

   407                                     curSor.iAnchorPos = iCharStartPostion;  

   408                                     iLastSubmitCount = curSor.iCursorPos - iCharStartPostion;

   409                                     //Fixed bug ID SAHN-7JDDC8

   410                                     }

   411                                 }

   412                             

   413                             if (curSor.iAnchorPos<0 || 

   414                                 curSor.iAnchorPos>edit->DocumentLengthForFep())

   415                                 {

   416                                 break;

   417                                 }

   418                             

   419                             // check repeated string 

   420                             if (len >= iLastSubmitCount)

   421                                 {

   422                                 TBuf<CAknFepManager::EMaximumFepWordLength> textToUncommit;

   423                                 textToUncommit.Zero();    

   424                                 

   425                                  edit->GetEditorContentForFep(textToUncommit, curSor.iAnchorPos, 

   426                                                            Min(curSor.Length(), 

   427                                                            CAknFepManager::EMaximumFepWordLength));

   428                                 

   429                                 repeatCount = RepeatStringFromLeft(s,textToUncommit);    

   430                                 curSor.iAnchorPos += repeatCount;

   431                                 if (curSor.iAnchorPos<0 || 

   432                                     curSor.iAnchorPos>edit->DocumentLengthForFep())

   433                                     {

   434                                     break;

   435                                     }

   436                                 }

   437                                 

   438                             if (curSor.iCursorPos > curSor.iAnchorPos)

   439                                 {

   440                                 edit->SetCursorSelectionForFepL(curSor);    

   441                                 }

   442                             }

   443                         }

   444                     }

   445                 else

   446                     {

   447                     TBuf<1> backSpace;

   448                     backSpace.Append(TChar(EKeyBackspace));

   449                     for(TInt i = 0; i < len; ++i)

   450                         {

   451                         SubmitUiPluginTextL(backSpace, EKeyEvent);

   452                         }

   453                     }

   454                 iFepMan.ClearFlag( CAknFepManager::EFlagSupressAutoUpdate );

   455                 

   456                 if (repeatCount > 0)

   457                     {

   458                     OnPenInputServerKeyEventL(s.Right(s.Length() - repeatCount));

   459                     

   460                     iLastSubmitCount += repeatCount;   

   461                     }

   462                 else

   463                     {

   464                     OnPenInputServerKeyEventL(s);    

   465                     }

   466                 }

   467                 break;

   468             case ESignalKeyEvent:

   469                 {

   470                 TPtr ptr( const_cast<TUint16*>(pBuf.Ptr()), pBuf.Length(), pBuf.Length() );

   471                 if(iFepMan.InputMode() == ELatin && (iPluginInputMode == EPluginInputModeVkb || 

   472                    iPluginInputMode == EPluginInputModeFSQ))

   473                     {

   474                     AdjustDataCase( ptr );

   475                     }

   476                 OnPenInputServerKeyEventL(pBuf);

   477               	}

   478               	break;

   479             case ESignalNotifyUpdateCba://Update CBA

   480                 {

   481                 TInt* cbaData = (TInt* )(pBuf.Ptr());

   482                 iFepMan.UpdateCbaL(*cbaData);

   483                 }

   484                 break;                    

   485             case ESignalHwNotifySctPopup:

   486                 iFepMan.LaunchSpecialCharacterTableL( 0,ETrue );//possible?

   487                 break;                      

   488             case ESignalSetAppEditorCursor:

   489                 {

   490                 TInt8 *ptrData = (TInt8* )(pBuf.Ptr());

   491                 TCursorSelection curSel = *(TCursorSelection* )(ptrData);

   492                 TBool sync = *(TBool *)(ptrData + sizeof(TCursorSelection));

   493                 

   494                 if ( iFepMan.UncommittedText().Length() > 0 )

   495                     {

   496                     iFepMan.PtiEngine()->CancelTimerActivity(); 

   497                     //using TryCloseUiL() to sync Fep state

   498                     //iFepMan.CommitInlineEditL();

   499                     iFepMan.TryCloseUiL();

   500                     }

   501                 //now change the cursor position

   502                 SetCursorSelectionL(curSel, sync);

   503                 }

   504                 break;

   505             case ESignalLaunchLanguageMenu:

   506                 LaunchPenInputLanguageSelectionL(ETrue);

   507                 break;                                       

   508             case ESignalLaunchOptionMenu:

   509             case ESignalLaunchOptionsMenu:

   510                 {

   511                 if (iInMenu || (!iPenInputMenu) || iPenInputMenu->IsShowing())

   512                     {

   513                     break;    

   514                     }

   515                 iLaunchMenu = ETrue;

   516                 if (PluginInputMode() == EPluginInputModeItut ||

   517                     PluginInputMode() == EPluginInputModeFSQ ||

   518                     PluginInputMode() == EPluginInputModeFingerHwr)

   519                     {

   520                     SetMenuState();

   521                     }                

   522                 else

   523                     {

   524                     ClosePluginInputUiL(ETrue);

   525                     }           

   526                 LaunchPenInputMenuL(R_AVKON_PENINPUT_OPTION_MENU_BAR);

   527                 }

   528                 break;

   529             case ESignalLayoutClosed:

   530                 ClosePluginInputModeL(ETrue);

   531                 if(iPenInputSvrConnected ) //lost foreground

   532                     {

   533                     iPenInputServer.LoseForeground();

   534                     }                

   535                 break;                    

   536             case ESignalCaseMode:

   537                 {

   538                 TInt* pluginCase = (TInt* )(pBuf.Ptr());    

   539                 iFepMan.ClearFlag(CAknFepManager::EFlagSupressAutoUpdate);

   540                 

   541                 if (ECaseInverseText == *pluginCase)

   542                     {

   543                     iFepMan.SetFlag(CAknFepManager::EFlagQwertyShiftMode);    

   544                     }

   545                 iCaseMan.SetCurrentCase(*pluginCase);

   546                 

   547                 if (ECaseInverseText == *pluginCase)

   548                     {

   549                     iFepMan.ClearFlag(CAknFepManager::EFlagQwertyShiftMode);    

   550                     }

   551                 }

   552                 break;

   553             case ESignalRange:

   554                 {

   555                 HideTooltipOnFSQL();

   556 

   557                 TInt newPrimaryRange = *(TInt* )(pBuf.Ptr());

   558                 // Addition for ITI features on FSQ, 

   559                 // when swith to other ranges from latin/native range, 

   560                 // need to commit text to fep and ptiengint if necessary

   561                 if ( EnableITIOnFSQ() && newPrimaryRange != ERangeEnglish 

   562                      && newPrimaryRange != ERangeNative )

   563                     {

   564                     iFepMan.CommitInlineEditL();

   565                     iFepMan.PtiEngine()->CommitCurrentWord();

   566                     }                

   567                 iPluginPrimaryRange = newPrimaryRange;

   568                 if (ELangJapanese == iSharedData.InputTextLanguage()

   569                     && ERangeNative == iPluginPrimaryRange )

   570                     {

   571                     TInt subrange = *(TInt* )( (TInt8* )(pBuf.Ptr()) + sizeof(TInt) );

   572                     iCurrentPluginInputFepUI->HandleCommandL(ECmdPenInputJapaneseSetSubRange, 

   573                                                              subrange);

   574                     }

   575                 SyncIndicatorWithPluginRangeL();

   576                 }

   577                 break;

   578             case ESignalLayoutUIChanged:

   579                 {

   580                 TInt8 *ptrData = (TInt8* )(pBuf.Ptr());

   581                 TBool switchByMode = *(TInt*)(ptrData);

   582                 if( switchByMode )

   583                     {

   584                     TInt mode = *(TInt* )( ptrData + sizeof(switchByMode) );

   585 					ClosePluginInputModeL(ETrue);               

   586                     iFepMan.TryCloseUiL();  

   587 					iPreferredUiMode = EFalse;

   588                     TryChangePluginInputModeByModeL((TPluginInputMode)mode, 

   589                                                     EPenInputOpenManually,

   590                                                     ERangeInvalid);

   591                     }

   592                 }

   593                 break;

   594             case ESignalCommitInlineText:

   595                 {

   596                 iFepMan.CommitInlineEditL();

   597                 }

   598                 break;

   599             case ESignalEnterMatchSelection:

   600                 {

   601                 TBool on = *((TInt*)(pBuf.Ptr()));

   602 

   603                 if (on)

   604                     {

   605                     EnterMatchSelectionState();

   606                     }

   607                 else

   608                     {

   609                     iFepMan.PluginUIManager()->SetFingerMatchSelectionState(EFalse);

   610                     }    

   611                 }

   612                 break;

   613             case ESignalSelectMatchSelectionText:

   614                 {

   615                 TInt* ptrData = (TInt*)(pBuf.Ptr());

   616                 TInt itemidx = *(ptrData);

   617                 TBool commit = *(ptrData + 1);

   618                 

   619                 iFepMan.UpdateInlineEditL(iSendAllList.iCandidates[itemidx], 

   620                                           iSendAllList.iCandidates[itemidx].Length());

   621                 

   622                 if (commit)

   623                     {

   624                     iFepMan.TryCloseUiL();

   625                     iFepMan.FepUI()->HandleCommandL(ESignalSelectMatchSelectionText);

   626                     }

   627                 else

   628                     {

   629                     iFepMan.PluginUIManager()->SetFingerMatchSelectionState(EFalse);

   630                     }    

   631                 

   632                 SendIcfDataL(EPluginSyncUpdatedText);

   633                 }

   634                 break;

   635             case ESignalEnterSpellMode:

   636                 {

   637                 iFepMan.LaunchEditWordQueryL();

   638                 }

   639                 break;

   640             case ESignalExitSpellMode:

   641                 {

   642                 TInt* ptrData = (TInt*)(pBuf.Ptr());

   643                 TBool exitbyok = *(ptrData);

   644 

   645                 exitbyok ? iFepMan.ExitPluginSpellModeByOk() : 

   646                            iFepMan.ExitPluginSpellModeByCancel();

   647                 }

   648                 break;

   649             case ESignalLaunchSCT:

   650             	{

   651             	iFepMan.LaunchSpecialCharacterTableL(0,ETrue);	

   652             	}

   653             	break;

   654             case ESignalGetEditMenuData:

   655                 {

   656                 //Calcuate which menu needed to add

   657                 iFepMan.GetPermittedEditorMenu(EFalse);

   658                 }

   659                 break;

   660             case ESignalEditorMenuCommand:

   661                 {

   662                 //Execute editor menu command

   663                 TInt* command = (TInt* )(pBuf.Ptr());

   664                 iFepMan.ProcessEditorMenuCommand(*command);

   665                 iCurrentPluginInputFepUI->HandleCommandL(ECmdPenInputFingerInputMode,

   666                                                          iFepMan.InputMode());

   667                     

   668                 iIndicatorImgID = 0;

   669                 iIndicatorTextID = 0;  

   670                 UpdateITUTIndicator();                

   671                 }

   672                 break;                

   673             case ESignalCharacterStart:

   674                 {

   675                 TBool charStart = *(TBool*)(pBuf.Ptr());

   676                 if( charStart )

   677                     {

   678                     MCoeFepAwareTextEditor* edit = iFepMan.FepAwareTextEditor(); 

   679                     if( !edit )

   680                         {

   681                         break;

   682                         }

   683                     TCursorSelection curSor;

   684                     edit->GetCursorSelectionForFep(curSor);

   685                     iCharStartPostion = Min( curSor.iCursorPos, curSor.iAnchorPos );          

   686 

   687                     }

   688                 else

   689                     {

   690                     iCharStartPostion = KInvalidValue;

   691                     }

   692                 }

   693                 break;

   694             case ESignalShowCandidate:

   695                 {

   696                 // Get candidate list

   697                 TInt activeIdx = 0;

   698                 CDesCArray* candidates = new (ELeave) CDesCArrayFlat

   699                                                  ( KDefaultCandidateArraySize );

   700         		CleanupStack::PushL( candidates );

   701         		iFepMan.GetCandidatesL( *candidates, activeIdx );

   702         		TFepITICandidateList candidateListData;

   703         		candidateListData.iItemArray = candidates;

   704         		candidateListData.iActiveIndex 

   705         		            = ( candidates->Count() >= 2 ) ? 1 : activeIdx;        		

   706         		ShowCandidateListL( candidateListData );        		

   707         		CleanupStack::PopAndDestroy( candidates );                

   708                 }

   709                 break;

   710             case ESignalSelectCandidate:

   711                 {

   712                 // Select candidate word on fsq

   713                 TInt index = *(TInt*)( pBuf.Ptr() );

   714                 CommitCandidateWordOnFSQL( index );                

   715                 break;

   716                 }

   717             case ESignalAcceptTooltip:

   718                 {

   719                 // Simulate Up key and then join in the key flow for HW

   720                 // to accept tooltip

   721                 TKeyEvent keyEvent = { EKeyUpArrow, EStdKeyUpArrow, 0, 0 };                  

   722                 CCoeEnv::Static()->SimulateKeyEventL( keyEvent, EEventKey );

   723                 

   724                 // commit tooltip text then commit inline                

   725                 iFepMan.CommitInlineEditL();

   726                 // Need to commit into engine, it will clear textbuffer in it.

   727                 iFepMan.PtiEngine()->CommitCurrentWord();

   728                 }

   729                 break;

   730             case ESignalStartInlineText:

   731                 {

   732                 if (!(iFepMan.IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction)))

   733                     {

   734 					TBuf<CAknFepManager::EMaximumFepWordLength> textToUncommit;

   735 					TBool comsumeKey;

   736 					

   737 					if (!(iFepMan.TryGetTextToUncommitL(textToUncommit, comsumeKey)))

   738 						{

   739 						// If T9 word length > 32, the navi key is consumed without action.

   740 						// Maybe should navigate inside word.

   741 						return comsumeKey;

   742 						}

   743 					iFepMan.PtiEngine()->ClearCurrentWord();

   744 					iFepMan.PtiEngine()->SetCurrentWord(textToUncommit); // this set the input sequence of PtiEngine          

   745 					iFepMan.StartInlineEditL(iFepMan.UncommittedText(), textToUncommit, 

   746 											 textToUncommit.Length(), EFalse);

   747 

   748                     // update ICF content

   749                     SendIcfDataL();

   750                     }

   751                 }

   752                 break;

   753             case ESignalCommitITIInlineText:

   754                 {

   755                 // Commit autocompletion

   756                 iFepMan.CommitInlineEditL();

   757                 // Need to commit into engine, it will clear textbuffer in it.

   758                 iFepMan.PtiEngine()->CommitCurrentWord();

   759                 }

   760                 break;

   761             default:

   762                 break;

   763             }

   764         }  

   765     return bHandled;

   766     }

   767     

   768 // -----------------------------------------------------------------------------

   769 // CAknFepPluginManager::EnterMatchSelectionState

   770 // Enter match selection state

   771 // (other items were commented in a header).

   772 // -----------------------------------------------------------------------------

   773 //

   774 TBool CAknFepPluginManager::EnterMatchSelectionState()

   775     {

   776     GetAllPredictiveCandidate();

   777     

   778     if (iCandidateList.Count() > 0)

   779         {

   780         SetFingerMatchSelectionState(ETrue);

   781         iFepMan.PluginUIManager()->ShowAllCandidates();

   782         return ETrue;

   783         }

   784     

   785     return EFalse;    

   786     }

   787 

   788 // -----------------------------------------------------------------------------

   789 // CAknFepPluginManager::HandleEventsFromFepL

   790 // Handle events from FEP

   791 // (other items were commented in a header).

   792 // -----------------------------------------------------------------------------

   793 //

   794 void CAknFepPluginManager::HandleEventsFromFepL( TInt aEventType, TInt aEventData )

   795     {

   796 

   797     if( iPluginInputMode == EPluginInputModeNone && 

   798         aEventType != EPluginEditorActivate && 

   799         aEventType != EPluginActivate &&

   800         aEventType != EPluginResourceChanged )

   801         {      

   802         return;

   803         }

   804         

   805     switch ( aEventType )

   806         {

   807         case EPluginEditorActivate:

   808             {

   809             ActivatePenInputL();

   810             RWsSession &ws = CCoeEnv::Static()->WsSession();

   811             TInt wgId =ws.GetFocusWindowGroup();

   812             iEditorPriority = ws.GetWindowGroupOrdinalPriority(wgId);

   813             }

   814             break;

   815         case EPluginActivate:

   816             {//The command is obsolete, use other commands

   817             //current only some Japanese menu commands call this

   818             ActivatePenInputL();    

   819             }            

   820             break;

   821         case EPluginCloseMode:

   822             {

   823             if (iPluginInputMode == EPluginInputModeItut && 

   824                 !iSharedData.PredictiveTextAutoCompleteOn())

   825             	{

   826             	return;

   827             	}

   828             

   829             ClosePluginInputModeL( aEventData );

   830             }

   831             break;

   832         case EPluginFocusItemDestroy:

   833             if( iFepMan.FepAwareTextEditor() )

   834                 {

   835                 iMfne = NULL;

   836                 if ( !aEventData )

   837                     {

   838                     RemoveLastFocusedWinFromOpenList();

   839                     }

   840                 else

   841                     {

   842                     ClosePluginInputUiL(ETrue);

   843                     }

   844                 }

   845             break;

   846         case EPluginSyncFepAwareText:

   847             {

   848             SyncFepAwareText( TPluginSync(aEventData) );

   849             }

   850             break;

   851         /*case EPluginActivateInGlobalNote:

   852             {

   853             OnFocusChangedL(ETrue);

   854             iPenInputServer.ActivatePeninputInNotesL();           

   855             }

   856             break;*/

   857         case EPluginMenuCmd:

   858             {

   859             ProcessMenuCommandL( aEventData );

   860             }

   861             break;

   862         case EPluginForegroundChanged:

   863             {

   864             iForegroundChange = ETrue;   

   865             iLaunchHelp = EFalse;    

   866             

   867             if (!aEventData && IsInGlobleNoteEditor())

   868                 {

   869                 ClosePluginInputUiL(ETrue);

   870                 if(iPenInputSvrConnected ) //lost foreground

   871                     {

   872                     iPenInputServer.LoseForeground();

   873                     }

   874                 }

   875             else

   876                 {

   877                 OnFocusChangedL( aEventData ) ;   

   878                 }

   879             }

   880             break;

   881         case EPluginFocusChanged:

   882             {

   883             OnFocusChangedL( aEventData );

   884             }

   885             break;

   886         case EPluginResourceChanged:

   887             {

   888 			iOrientationChangedfromUI = ETrue;

   889             OnResourceChangedL( aEventData );

   890 			iOrientationChangedfromUI = EFalse;

   891             }

   892             break;

   893         case EPluginFaseSwap:

   894             {

   895             iFastSwapByMenu = aEventData;

   896             }

   897             break;

   898         case EPluginKeyEvent:

   899             {

   900             HandleKeyEventL( aEventData );

   901             }

   902             break;

   903         case EPluginUpdateIndicator:

   904             {

   905             UpdateITUTIndicator();

   906             }

   907             break;

   908         case EPluginPreview:

   909             {

   910             iCurrentPluginInputFepUI->HandleCommandL(ECmdPenInputCharacterPreview, 

   911                aEventData);                 

   912             }

   913             break;

   914         case EPluginPromptChanged:

   915             {

   916             SetPromptText( EFalse );

   917             }

   918             break;

   919         case ELostForeground:

   920             {

   921             if(iPenInputSvrConnected ) //lost foreground

   922                 {

   923                 iPenInputServer.LoseForeground();

   924                 }

   925             }

   926             break;

   927         case EPluginShowTooltip:

   928         	{

   929         	ShowTooltipOnFSQL( aEventData );

   930         	}

   931         	break;

   932         case EPluginHideTooltip:

   933         	{

   934         	HideTooltipOnFSQL();

   935         	}

   936         	break;

   937         default:

   938             break;

   939         }

   940     }

   941             

   942 // -----------------------------------------------------------------------------

   943 // CAknFepPluginManager::TryChangePluginInputModeByModeL

   944 // Change current input method to plugin input method with specified layout UI id.

   945 // (other items were commented in a header).

   946 // -----------------------------------------------------------------------------

   947 //

   948 TBool CAknFepPluginManager::TryChangePluginInputModeByModeL

   949     (TPluginInputMode aSuggestMode, TInt aOpenMode,TInt aSuggestRange)

   950     {

   951     if ( iSharedData.QwertyInputMode() )

   952         {

   953         return EFalse;

   954         }

   955 

   956     TBool rtn = EFalse;

   957     if ( iFepMan.ExtendedInputCapabilities() & 

   958         CAknExtendedInputCapabilities::EInputEditorDisableVKB ) 

   959         {

   960         return EFalse;

   961         }

   962 

   963     if (! ConnectServer() )

   964         {

   965         return EFalse;

   966         }

   967     

   968     if ((iPenInputServer.PreferredUiMode() != EPluginInputModeNone) && iPreferredUiMode )

   969         {

   970         aSuggestMode = iPenInputServer.PreferredUiMode();

   971         }

   972         

   973     if (!GetCurSuggestMode( aSuggestMode ))

   974         {

   975         return EFalse;    

   976         }

   977     

   978     // add by jiawenjuan to remember the old fep aware editor.

   979     TBool cleanContent = EFalse;   

   980     if(iOldFepAwareEditor != iFepMan.FepAwareTextEditor())

   981         {

   982         cleanContent = ETrue;

   983         iOldFepAwareEditor = iFepMan.FepAwareTextEditor();

   984         }

   985 

   986     if( !iAdjustDataQueryTimer )

   987         {

   988         iAdjustDataQueryTimer = CPeriodic::NewL(CActive::EPriorityStandard);

   989         }

   990             

   991     // Addition for ITI features on FSQ, if iITISettingDialogOpen == ETrue,

   992     // it means that predictive setting dialog is closed, then re-open FSQ again.

   993     // Need to set iITISettingDialogOpen = EFalse at this moment

   994     if ( iITISettingDialogOpen )

   995     	{

   996     	iITISettingDialogOpen = EFalse;

   997     	}  

   998     

   999     // getting a new ui manager object corresponded in aMode.

  1000     TInt uiLanguage = iSharedData.DisplayLanguage();

  1001     if( uiLanguage == ELangTest )

  1002         {

  1003         uiLanguage = User::Language();

  1004         }

  1005     

  1006     if ( iDefaultOrientation == -1 )

  1007         {

  1008         iDefaultOrientation = iAvkonAppUi->Orientation();

  1009         }

  1010     iPenInputServer.BackgroudDefaultOri( iDefaultOrientation );

  1011     

  1012     TPixelsTwipsAndRotation size; 

  1013     CCoeEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(size);

  1014     TBool landscape = size.iPixelSize.iWidth > size.iPixelSize.iHeight;     

  1015     TBool disableFSQ = 

  1016         (  aSuggestMode == EPluginInputModeFSQ &&

  1017            ( iDefaultOrientation == CAknAppUiBase::EAppUiOrientationPortrait ||

  1018 		     ( !landscape && !iAvkonAppUi->OrientationCanBeChanged() ) ) );

  1019           

  1020     if ( disableFSQ )

  1021         {

  1022         iPenInputServer.SetDisabledLayout( EPluginInputModeFSQ );

  1023         }

  1024 

  1025     if ( aSuggestMode == EPluginInputModeFSQ )

  1026         {

  1027         TPluginInputMode tempInputMode = iPluginInputMode;           

  1028         iPluginInputMode = EPluginInputModeFSQ;

  1029         

  1030         if (disableFSQ )

  1031             {

  1032             iPluginInputMode = tempInputMode;

  1033             aSuggestMode = EPluginInputModeItut;

  1034             }

  1035         else

  1036             {

  1037             if ( !iSharedData.AutoRotateEnabled() )

  1038                 {

  1039                 iFepMan.SetNotifyPlugin( EFalse );

  1040                 iAvkonAppUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationLandscape );

  1041                 iFepMan.SetNotifyPlugin( ETrue );

  1042                 iOrientationChanged = ETrue;

  1043                 }

  1044         

  1045 		    CCoeEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(size);

  1046             landscape = size.iPixelSize.iWidth > size.iPixelSize.iHeight;  

  1047             if( !landscape )

  1048                 {

  1049                 iPluginInputMode = tempInputMode;

  1050                 aSuggestMode = EPluginInputModeItut;

  1051                 }

  1052             }

  1053         }

  1054     else if ( iOrientationChanged )

  1055         {

  1056         iFepMan.SetNotifyPlugin( EFalse );

  1057         iAvkonAppUi->SetOrientationL( (CAknAppUiBase::TAppUiOrientation)iDefaultOrientation );

  1058         iFepMan.SetNotifyPlugin( ETrue );

  1059         iOrientationChanged = EFalse;

  1060         }

  1061     

  1062     TBool isSplit = IsEditorSupportSplitIme();

  1063     // temp code for Chinese split view

  1064     if ( iSharedData.PenInputLanguage() == ELangPrcChinese || 

  1065          iSharedData.PenInputLanguage() == ELangTaiwanChinese ||

  1066          iSharedData.PenInputLanguage() == ELangHongKongChinese )

  1067         {

  1068         isSplit = EFalse;

  1069         }    

  1070     iLangMan.SetSplitView(isSplit);

  1071  

  1072     TInt inputLang = iFepMan.InputLanguageCapabilities().iInputLanguageCode;

  1073     MAknFepManagerInterface* fepUI = iLangMan.GetPluginInputFepUiL(

  1074                                                     aSuggestMode, 

  1075                                                     inputLang,

  1076                                                     uiLanguage,

  1077                                                     &iPenInputServer); 

  1078     iCurrentPluginInputFepUI = fepUI;

  1079     

  1080     if ( iCurrentPluginInputFepUI )     

  1081         {

  1082         // fix EVWG-7U73HS

  1083         iPenInputServer.DimUiLayout(EFalse);

  1084         

  1085         AddCurrentWinToOpenListL();

  1086         if (iPluginInputMode == EPluginInputModeItut)

  1087             {

  1088             iIndicatorImgID = 0;

  1089             iIndicatorTextID = 0;           

  1090             }

  1091 

  1092         iPluginInputMode = (TPluginInputMode)iLangMan.CurrentImePlugin()->CurrentMode();

  1093 

  1094         //following codes is used to tell MFNE editor the Touch Input 

  1095         //has been opened. Because MFNE editor has no editorstate, so 

  1096         //use this way to implement this.

  1097         if ( iFepMan.IsMfneEditor() )

  1098             {

  1099             MCoeFepAwareTextEditor* mfne( iFepMan.FepAwareTextEditor() );

  1100             iMfneChanged = ( iMfne != mfne );

  1101             iMfne = mfne;

  1102             InformMfneUiStatusL( ETrue );  

  1103             }

  1104 

  1105         // Addition for ITI features on FSQ

  1106         // Before open touch window, need to set iPluginPrimaryRange = 0

  1107         // which means use the default range.

  1108         iPluginPrimaryRange = 0;

  1109         

  1110         InitializePluginInputL(aOpenMode, aSuggestRange, cleanContent);

  1111         

  1112         //save plugin input mode to repository

  1113         if( iPenInputServer.PreferredUiMode() == EPluginInputModeNone )

  1114             {

  1115             //do not remember application set input mode

  1116             iSharedData.SetPluginInputMode(iPluginInputMode);

  1117             }

  1118             

  1119         if (CurrentFepInputUI())

  1120            	{

  1121            	CurrentFepInputUI()->SetInputLanguageL((TLanguage)inputLang);

  1122            	CurrentFepInputUI()->SetMode(iFepMan.InputMode(), ETrue, EFalse);		

  1123            	}

  1124 			

  1125         if(!iOrientationChangedfromUI)

  1126 		    {

  1127 		    iFepMan.UpdateCbaL( NULL );

  1128 		    }

  1129         

  1130         // Notify application touch window state

  1131         NotifyAppUiImeTouchWndState( ETrue );

  1132 

  1133         rtn = ETrue;

  1134         }