1 /*

     2 * Copyright (c) 2002-2008 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 *       Provides the CAknFepManager methods.

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include <uikon/eikdefmacros.h>

    31 #endif

    32 #include "AknFepManager.h"

    33 #include "AknFepManagerInterface.h" // MAknFepManagerInterface

    34 #include "aknfepindicator.h"

    35 #include "AknFepPanic.h"

    36 #include "AknFepKeyCatcher.h"

    37 #include "AknFepGlobalEnums.h"

    38 #include "AknFepCaseManager.h"

    39 #include "AknFepHashKeyManager.h"

    40 #include "AknFepSharedDataInterface.h"

    41 #include "AknFepInlineTextDecorator.h"

    42 #include "AknFepUiManagerBase.h"

    43 #include "AknFepUiManagerChinese.h"

    44 #include "AknFepUiManagerWestern.h"

    45 

    46 #include "AknFepPluginManager.h"

    47 #include "AknFepUiIndicInputManager.h"

    48 #include "AknFepUiIndicEnums.h"

    49 #include <AknFepUIStylusPopupMenu.h>

    50 #include "aknfepuispellinputpane.h"

    51 

    52 #include <bautils.h>

    53 #include <coeaui.h>                 //CCoeAppUi

    54 #include <aknedsts.h>               //CAknEdwinState

    55 #include <uikon.hrh>                //keys

    56 #include <aknenv.h>                 //CAknEnv

    57 #include <PtiEngine.h>              //CPtiEngine

    58 #include <AknJapaneseReading.h>     //CAknJapaneseReading

    59 #include <featmgr.h>                //FeatureManager

    60 #include <e32base.h>                //CPeriodic

    61 #include <PtiDefs.h>                //keys

    62 #include <fepipext.h>               //MCoeFepSpecificExtensions

    63 

    64 #include <aknsoundsystem.h>

    65 #include <avkon.rsg>

    66 #include <avkon.hrh>

    67 

    68 #include <tagma.h>

    69 #include <frmtview.h>

    70 #include <aknedformaccessor.h>

    71 

    72 #include <aknfep.rsg>

    73 #include <avkon.mbg>

    74 

    75 #include "aknconsts.h"

    76 #include <aknfeppeninputenums.h>

    77 #include <eikproc.h>                // User Dictionary

    78 #include <eikapp.h>                 // User Dictionary

    79 

    80 #include <StringLoader.h>

    81 

    82 #include <centralrepository.h>

    83 #include <AknFepInternalCRKeys.h>

    84 #include <settingsinternalcrkeys.h>

    85 #include <AknUtils.h>

    86 #include <AknCustomCursorSupport.h>

    87 #include <PtiKeyMappings.h>

    88 #include <aknfeppeninputimeplugin.h>

    89 #include <peninputcmd.h>

    90 

    91 #include <AknSettingCache.h>

    92 #include <aknextendedinputcapabilities.h>

    93 #include <AvkonInternalCRKeys.h>

    94 #include <hlplch.h>

    95 #include <aknfepdocumentnavigation.h>

    96 

    97 #include <eikcolib.h>

    98 #include <akntoolbar.h>

    99 

   100 #include <eikfrlbd.h>

   101 #include <eikccpu.h>

   102 #include <aknappui.h>

   103 #include <apgwgnam.h>

   104 #ifdef RD_INTELLIGENT_TEXT_INPUT

   105 #include "AknFepUiWordPopupContent.h"

   106 #include "AknFepFnKeyManager.h"

   107 //#include <csxhelp/cp.hlp.hrh> 

   108 #endif //RD_INTELLIGENT_TEXT_INPUT

   109 

   110 #ifdef RD_TACTILE_FEEDBACK

   111 #include <touchfeedback.h>

   112 #endif //RD_TACTILE_FEEDBACK

   113 #include "AknFepThaiSCTSelector.h"

   114 

   115 //the follow 10 filse include for phrase creation

   116 #include <bamdesca.h>

   117 #include <eikspane.h> //CEikStatusPane 

   118 #include <akntitle.h> //CAknTitlePane 

   119 #include <akntoolbar.h> //CAknToolBar 

   120 #include <aknappui.h>

   121 #include "AknFep.hrh"

   122 #include "aknfepuserdbdlg.h"

   123 #include "aknfepzhuyinkeyhandler.h"

   124 #include "AknFepZhuyinAnalyser.h"

   125 #include "AknFepZhuyinAnalyserDb.h"

   126 

   127 #include <aknnavi.h> 

   128 #include <aknnavide.h> 

   129 

   130 #include <eikedwin.h>

   131 #include <aknCharMap.h>

   132 

   133 const TInt KSelectItemSize(10);

   134 _LIT(KAknFepResourceFileName, "z:\\resource\\fep\\aknfep.rsc");

   135 _LIT(KFEPPREDINPUT_HLP_INPUT, "PREDINPUT_HLP_INPUT"); // 

   136 

   137 #define text_to_field_mode_hash_key ';'

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

   139 #define __SHIFT_KEY_LOOP

   140 

   141 // EAknEditorNativeKeysNumberModeKeymap is used for example in MFNE editors.

   142 #define EAknEditorNativeKeysNumberModeKeymap EAknEditorReservedInternalUseKeymap

   143 

   144 // UID of user dictionary application

   145 const TUid KUidUserDictApp = {0x101F8645};

   146 

   147 const TText KAknFEPLineFeedSymbol = 0x21B2;

   148 const TText KAknFEPMirroredLineFeedSymbol = 0x21B3;

   149 const TText KAknFEPZeroKey = 0x30;

   150 

   151 // inline text decoration potentially adds 2 directional markers for every "real" character. Buffer needs to be 3 x predictive engine bufsize

   152 const TInt KMaxInlineEditSize( 3 * CAknFepManager::EMaximumFepWordLength );

   153 

   154 // Maximum number of chunks to navigate throught attempting to get to the visual end of a selection.

   155 // Since chunks are arranged only within a line, this should be more than the number of chunks likely in

   156 // a single line of text

   157 const TInt KMaxChunkWalkIterations(20);

   158 

   159 // This command is is used for setting empty CBA.

   160 const TInt KNullCommandId = 0;

   161 

   162 _LIT_SECURE_ID(KPhoneSecureId, 0x100058b3);

   163 

   164 #ifdef RD_HINDI_PHONETIC_INPUT

   165 

   166 const TUint KQuestionMark = 0x003F;

   167 

   168 #endif

   169 

   170 // Ccpu key events. 

   171 /*As part of build warnings commenting this perticular code it might require when touch is enabled.

   172 const TKeyEvent KEditorCopyEvent = {3, 67, 161, 0};  // Ctrl + C

   173 const TKeyEvent KEditorCutEvent  = {24, 88, 161, 0}; // Ctrl + X

   174 */

   175 

   176 const TInt KTouchInputPreviewOn = 1;

   177 const TInt KTouchInputPreviewOff = 0;

   178 

   179 #ifdef  RD_SCALABLE_UI_V2

   180 const TKeyEvent KAknCcpuCopyEvent = {EKeyF18, EEikCmdEditCopy, EModifierCtrl, 1};  // Copy event for AknCcpuSupport

   181 const TKeyEvent KAknCcpuCutEvent  = {EKeyF18, EEikCmdEditCut, EModifierCtrl, 1};   // Cut event for AknCcpuSupport

   182 

   183 const TInt KMaxMenuSize = 23;

   184 const TInt KEditorMenuPermitedSend[KMaxMenuSize] = 

   185     {         

   186     EJapanFepCmdModeHiragana,

   187     EJapanFepCmdModeKatakana,

   188     EJapanFepCmdEditModeAlpha,

   189     EJapanFepCmdEditModeNumber,

   190     EJapanFepCmdModeFullWidth,

   191     EJapanFepCmdModeHalfWidth,

   192     EChinFepCmdModePinyin,

   193     EChinFepCmdModeZhuyin,

   194     EChinFepCmdModeStroke,

   195     EAknCmdT9PredictiveT9Off,

   196     EAknCmdMultitapPredictiveT9On,

   197     EJapanFepCmdMultitapPredictiveT9On,

   198     EChinFepCmdModeZhuyinFind,

   199     EChinFepCmdModeStrokeFind,

   200     EAknCmdEditModeAlpha,

   201     EAknCmdEditModeLatinText,

   202     EChinFepCmdModeLatinUpper,

   203     EChinFepCmdModeLatinLower,

   204     EAknCmdEditModeNumber,

   205     EChinFepCmdModeNumber,

   206     EAknCmdEditModeArabicIndicNumber,

   207     EAknCmdEditModeEasternArabicIndicNumber,

   208     EAknCmdEditModeIndicNumber

   209     };   

   210      

   211 #endif // RD_SCALABLE_UI_V2 

   212 

   213 

   214 // Number modes used by Arabic or Hindi.

   215 enum TNonLatinNumberModes

   216     { 

   217     ENbrModeLatin,

   218     ENbrModeArabic = 1,

   219     ENbrModeIndic = 1

   220     };

   221 

   222 // Number mode type

   223 enum TNonLatinNumberModeType

   224     {

   225     ENbrModeTypeArabic,

   226     ENbrModeTypeIndic,

   227     ENbrModeTypeEasternArabic //for Urdu & Farsi languages

   228     };

   229     

   230 // The passwd timeout is same as defined on CEikSecretEditor.

   231 const TInt KSyncPasswdTimeout = 1000000;

   232 

   233 #ifdef RD_SCALABLE_UI_V2

   234 TUid AppUidFromWndGroupId(TInt aWndGrpId);

   235 extern TUid GetCurAppUid();

   236 extern TBool IsGlobalNotesApp(TUid& aUid);

   237 TInt GetForegroundTaskAppWgId();

   238 #endif

   239 #ifdef RD_INTELLIGENT_TEXT_INPUT

   240 const TInt KWordToFocusInCandidateList = 1;

   241 #endif

   242 

   243 LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

   244 

   245 //

   246 // Class TTextDirectionalInfo

   247 //

   248 /**

   249 * The implementation inializes with well-defined "null" state

   250 */

   251 CAknFepManager::TTextDirectionalInfo::TTextDirectionalInfo() : 

   252 iDirectionalStatus(EUnknown), iBlockEnvironment(EUndefined)

   253     {}

   254 

   255 void CAknFepManager::TTextDirectionalInfo::SetDirectionFromChunk( 

   256                const CTmTextLayout::TTmChunkDescription& aChunk )

   257     {

   258     if ( aChunk.iStart >= 0 ) // Condition for valid block. Does nothing otherwise

   259         iDirectionalStatus = aChunk.iRightToLeft ? ERightToLeft : ELeftToRight;

   260     }

   261 

   262 

   263 void TFepLanguageTranslation::ReadFromResource(TResourceReader& aReader)

   264     {

   265     iName.Set(aReader.ReadTPtrC());

   266     iLanguageId = aReader.ReadInt16();

   267     iCommandId = aReader.ReadInt16();

   268     }

   269 

   270 

   271 CAknFepManager::CAknFepManager(CCoeEnv& aConeEnvironment)

   272     :CCoeFep(aConeEnvironment),

   273     iAsyncResouceChanged(EActivePriorityDefault),

   274     iPreviousEditingState(EStateNone),

   275     iInputCapabilities(TCoeInputCapabilities::ENone),

   276     iModeBefore(ELatin),

   277     #ifdef RD_INTELLIGENT_TEXT_INPUT

   278     iKeyPressedDuringShift(EFalse),

   279 #endif

   280     iCharWidth(EHalfWidthChar),

   281     iAsyncOwnSimulateKey(EActivePriorityDefault),

   282     iLongThai0Key(EFalse),

   283     iEditCharsPtr(0,0),

   284     iComposChrFlag(0),

   285     iIsUserdbdlgActive(0),

   286     iLongClearAfterCloseUI(EFalse),

   287     // phrase creation

   288     iPhraseCreation(0),

   289     iPinyinPhraseCreation(0),

   290     iEntryPhrase(0)

   291     

   292 

   293     {

   294     }

   295 

   296 void CAknFepManager::ConstructL(const CCoeFepParameters& aFepParameters)

   297     {

   298     BaseConstructL(aFepParameters);

   299     iUiInterface = CAknFepUIInterface::NewL();

   300     iIndicator = iUiInterface->NewIndicatorL();

   301     iPreviousIndicator = CAknEnv::Static()->SwapEditingStateIndicator(iIndicator);

   302 

   303     // Set up resources

   304     TFileName resourceName(KAknFepResourceFileName);

   305     CCoeEnv* coeEnv = CCoeEnv::Static();

   306     BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceName);

   307     iResId = coeEnv->AddResourceFileL(resourceName);

   308 

   309     // Save Japanese Feature support to a member variable

   310     iFeatureSupportedJapanese = FeatureManager::FeatureSupported(KFeatureIdJapanese);

   311 

   312     iUiLanguage = User::Language();

   313     

   314     // Shared Data

   315     iSharedDataInterface = CAknFepSharedDataInterface::NewL(this);

   316 

   317     TInt previUiLanguage = iSharedDataInterface->PluginUILanguage();

   318 

   319     if (iUiLanguage != previUiLanguage)

   320         {

   321         

   322         // if UI language has changed we need to set text input language according to UI language

   323         iSharedDataInterface->SetPluginUILanguage(iUiLanguage);

   324         iSharedDataInterface->SetInputTextLanguage(0);  // signals that it needs to be updated

   325         }

   326 

   327     if (!iSharedDataInterface->InputMode()) //not initialised yet - first time device is switched on

   328         {

   329         switch (iUiLanguage)

   330             {

   331             case ELangPrcChinese:

   332                 iSharedDataInterface->SetInputMode(EPinyin);

   333                 break;

   334             case ELangTaiwanChinese:

   335                 iSharedDataInterface->SetInputMode(EZhuyin);

   336                 break;

   337             case ELangHongKongChinese:

   338                 iSharedDataInterface->SetInputMode(EStroke);

   339                 iSharedDataInterface->SetCangJieMode(ECangJieNormal);

   340                 break;

   341             case ELangJapanese:

   342                 iSharedDataInterface->SetInputMode(EHiraganaKanji);

   343                 break;

   344             case ELangKorean:

   345                 iSharedDataInterface->SetInputMode(EHangul);

   346                 break;

   347             case ELangHindi:

   348                 iSharedDataInterface->SetInputMode(EHindi);

   349                 break;

   350             default:

   351                 iSharedDataInterface->SetInputMode(ELatin);

   352                 break;

   353             }

   354         }

   355 

   356     iUiInterface->SetFepMenuObserver(this);

   357    

   358     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   359 

   360     // A process instantiating Fep may miss ECapabilityWriteDeviceData capability, 

   361     // which is needed for updating locale repository.

   362     // A workaround is to delay change up to a process that has the capability

   363     TSecurityInfo info;

   364     info.Set(RProcess());

   365 

   366     TBool hasCapability = info.iCaps.HasCapability(ECapabilityWriteDeviceData);

   367     

   368     if (!inputLanguage && hasCapability)

   369         {

   370         // set correct input language

   371         inputLanguage = SubstituteSublanguageId(iUiLanguage);

   372         

   373         // If Ptiengine is not initialize, initialize it

   374         if (!iPtiEngine)

   375             {

   376             iPtiEngine = CPtiEngine::NewL(ETrue);    

   377             }         

   378         // If still not found, default to english.

   379         if (!iPtiEngine->GetLanguage(inputLanguage))

   380             {

   381             inputLanguage = ELangEnglish;   

   382             }

   383         

   384         // Set the current input language

   385         iSharedDataInterface->SetInputTextLanguage(inputLanguage);

   386         

   387         // update numeric input

   388         if ( iUiLanguage == ELangArabic ) 

   389             {

   390             SetDefaultNumberMode( ENbrModeArabic, 

   391                                   ENbrModeTypeArabic );

   392             }            

   393         else if ( ( iUiLanguage == ELangUrdu  ) || 

   394                   ( iUiLanguage == ELangFarsi  ) )

   395             {

   396             SetDefaultNumberMode( ENbrModeArabic, 

   397                                   ENbrModeTypeEasternArabic );

   398             }

   399 		else if ( TAknFepUiIndicInputManager::IsScriptDevanagari( iUiLanguage ) )

   400             {

   401             SetDefaultNumberMode( ENbrModeLatin, 

   402                                   ENbrModeTypeIndic );

   403             }

   404         else

   405             {           

   406             SetDefaultNumberMode( ENbrModeLatin, ENbrModeTypeArabic );

   407             }

   408         }

   409         

   410     iSctEditChars = HBufC::NewL( 10 );

   411     

   412 #ifdef RD_INTELLIGENT_TEXT_INPUT

   413     // Predictive QWERTY (XT9) changes ---->

   414     	if(CCoeEnv::Static()->AppUi())

   415 				iExactWordPopupContent = iUiInterface->CreateWordPopupContentL();

   416     // Predictive QWERTY (XT9) changes <----

   417 #endif //RD_INTELLIGENT_TEXT_INPUT

   418     // If the following line is uncommented, the FEP is fully constructed

   419     // for all applications at application startup.

   420     // ConstructFullyL();

   421     iShiftKeypressMonitor = CPeriodic::NewL(CActive::EPriorityStandard);

   422 #ifdef RD_INTELLIGENT_TEXT_INPUT

   423     iFnKeyManager = CAknFepFnKeyManager::NewL( *this,iSharedDataInterface );

   424 #endif

   425     TRAPD(result,iKeyCatcher = CAknFepKeyCatcher::NewL(*this));

   426     if(result == KErrNone)

   427         {

   428         iKeyCatcher->ActivateL();

   429         }

   430     // the follow 3 objects for phrase creation

   431     iZhuyinKeyHandler = CZhuyinKeyHandler::NewL();

   432     iZhuyinAnalyserDb = CZhuyinAnalyserDbFeed::NewL(EPinyinAnalyserTypeZhuyin);

   433     iZhuyinAnalyser = CAknFepZhuyinAnalyser::NewL(iZhuyinAnalyserDb);

   434     iAknFepThaiSCTSelector = CAknFepThaiSCTSelector::NewL();

   435     iHybridAplphaChangedToAlphanumeric = EFalse;

   436     iLastFocusedEditor = NULL;

   437     iFepAwareDialogParentEditor = NULL;

   438     }

   439 

   440 void CAknFepManager::ConstructFullyL()

   441     {

   442     if (!iPtiEngine)

   443         {

   444         iPtiEngine = CPtiEngine::NewL(ETrue);    

   445         } 

   446     

   447     if ( !(iPtiEngine->GetLanguage(iSharedDataInterface->InputTextLanguage())) )

   448         {

   449         // If input language cenrep value is set to language unknown to PtiEngine,

   450         // try to reset based on UI-language. 

   451         TInt inputLang = SubstituteSublanguageId(iUiLanguage);

   452         

   453         // If still not found, default to english.

   454         if (!iPtiEngine->GetLanguage(inputLang))

   455             {

   456             inputLang = ELangEnglish;   

   457             }

   458         iSharedDataInterface->SetInputTextLanguage(inputLang);      

   459         }      

   460 #ifdef RD_INTELLIGENT_TEXT_INPUT

   461 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   462     if (iPtiEngine->GetLanguage(iSharedDataInterface->InputTextLanguageSecondary()) == NULL)

   463         {

   464         // If secondary input language is unknown to PtiEngine, set it to none

   465         iSharedDataInterface->SetInputTextLanguageSecondary(0);

   466         }

   467 #endif //FF_DUAL_LANGUAGE_SUPPORT

   468 #endif

   469         

   470     if(NULL == iKeyCatcher)

   471         {

   472         iKeyCatcher = CAknFepKeyCatcher::NewL(*this);    

   473         iKeyCatcher->ActivateL();

   474         }

   475     

   476     iConcatenationTimer=CPeriodic::NewL(CActive::EPriorityStandard);

   477     iPostEventCheck=CIdle::NewL(CActive::EPriorityStandard);

   478     iChrKeypressMonitor = CPeriodic::NewL(CActive::EPriorityStandard);

   479 

   480     CCoeEnv* coeEnv = CCoeEnv::Static();

   481     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   482 #ifdef RD_INTELLIGENT_TEXT_INPUT

   483 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   484     TInt inputLanguageSecondary = iSharedDataInterface->InputTextLanguageSecondary();

   485 #endif //FF_DUAL_LANGUAGE_SUPPORT

   486 #endif

   487     SetWesternPredictive(iSharedDataInterface->PredictiveTextOn());

   488 #ifndef RD_INTELLIGENT_TEXT_INPUT

   489     iIsAutoCompleteOn = iSharedDataInterface->PredictiveTextAutoCompleteOn(); // AutoCompletion disabled by Default 

   490 #endif	//RD_INTELLIGENT_TEXT_INPUT

   491 #ifdef RD_INTELLIGENT_TEXT_INPUT

   492     iIsAutoCompleteOn = iSharedDataInterface->PredictiveTextAutoCompleteOn(); // AutoCompletion disabled by Default 

   493     iTypingCorrectionLevel = iSharedDataInterface->PredictiveTextTypingCorrectionLevel();

   494     iIsNumberCandidateShown = iSharedDataInterface->PredictiveTextNumberCandidateShown();

   495     TInt primaryCandidateValue = iSharedDataInterface->PredictiveTextPrimaryCandidate();

   496     if( primaryCandidateValue == 0)

   497 		iPrimaryCandidate = ETrue;

   498 	else if(primaryCandidateValue == 1)

   499 		iPrimaryCandidate = EFalse; 

   500 #endif // RD_INTELLIGENT_TEXT_INPUT

   501     iJapanesePredictive = iSharedDataInterface->PredictiveTextJapaneseOn();

   502     iQwertyInputMode = iSharedDataInterface->QwertyInputMode();

   503     iMultiTapTimer = iSharedDataInterface->MultiTapTimer();

   504     iJapaneseQwertyFlags = iSharedDataInterface->JapaneseQwertyFlags();

   505 #ifdef RD_INTELLIGENT_TEXT_INPUT

   506     if(!iFnKeyManager)

   507         {

   508         iFnKeyManager = CAknFepFnKeyManager::NewL( *this,iSharedDataInterface );

   509         }    

   510 #endif

   511     iCaseMan = CAknFepCaseManager::NewL(*this);

   512     iLangMan = CAknFepLanguageManager::NewL(this, iCaseMan);

   513     iPtiEngine->ActivateLanguageL(inputLanguage);

   514 #ifdef RD_INTELLIGENT_TEXT_INPUT

   515 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   516     iPtiEngine->SetSecondaryInputL(inputLanguageSecondary);

   517 #endif //FF_DUAL_LANGUAGE_SUPPORT

   518 #endif

   519     iLangMan->SetInputLanguageL(inputLanguage);

   520     SetInputLanguageCapabilities(inputLanguage);

   521     iCurrentFepUI = iLangMan->GetFepUI(ELatin, iCharWidth, IsPredictive(ELatin));

   522 

   523     iLastKeyPressedWasHashKey = EFalse;

   524     iDeviceSupportsRtlLanguage = DeviceSupportsRTLLanguageL();

   525 

   526     TResourceReader reader;

   527     // get character from resource to represent an 'enter' character

   528     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_SPACE_SYMBOL);

   529     iSpaceCharacterCode = reader.ReadUint16();

   530     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_FULLWIDTHSPACE_SYMBOL);

   531     iFullWidthSpaceCharacterCode = reader.ReadUint16();

   532     CleanupStack::PopAndDestroy(2); //reader

   533 

   534     //initialise states

   535     iMode = EAknEditorNullInputMode; //Force a sync of mode...

   536     SyncStates(EAknFepStateNull);

   537     ResetFlags();

   538     ResetExtendedFlags();

   539 

   540     ReadHashKeyLoopL();

   541     iHashKeyMan = CAknFepHashKeyManager::NewL(*this, iCaseMan);

   542     SetHashKeyStyle();

   543     iInlineTextDecorator = new (ELeave) CAknFepInlineTextDecorator;

   544     if (IsFeatureSupportedJapanese())

   545         {

   546         CAknJapaneseReading::CreateL(iPtiEngine);

   547         }

   548     // setting call back

   549     TCallBack callback(DoSimulateKey, this);

   550     iAsyncOwnSimulateKey.Set(callback);

   551     

   552     TCallBack resourcechangedcallback(HandleResourceChangedCallback,this);

   553     iAsyncResouceChanged.Set(resourcechangedcallback);

   554 #ifdef RD_SCALABLE_UI_V2

   555     iFepPluginManager = CAknFepPluginManager::NewL

   556         ( *this, *iSharedDataInterface, *iLangMan, *iCaseMan);

   557     iNotifyPlugin = ETrue;

   558 #endif //RD_SCALABLE_UI_V2

   559 

   560     iFepFullyConstructed = ETrue;

   561 #ifdef RD_INTELLIGENT_TEXT_INPUT

   562     iIsFnKeyMapped = IsFnKeyMappedL();

   563     iKeyboardType = (TPtiKeyboardType)iSharedDataInterface->KeyboardLayout();

   564 #endif

   565     }

   566 

   567 CAknFepManager::~CAknFepManager()

   568     {

   569 #ifdef RD_PF_SEC_APPARC

   570     delete iNullService;

   571 #else

   572     //Embedding - removing created document

   573     if ( iEmbedded )

   574         {

   575         CEikonEnv::Static()->Process()->DestroyDocument(iEmbedded); // User dictionary

   576         iEmbedded = NULL;

   577         }

   578 #endif

   579     if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   580         {

   581         SetFlag(CAknFepManager::EFlagSupressAutoUpdate);

   582         TRAPD(err, CommitInlineEditL())

   583         if (err)

   584             {

   585             CleanUpFep();

   586             }

   587         }

   588         

   589     if ( EditorState() )

   590         {

   591         EditorState()->SetObserver(NULL);    

   592         }        

   593     if (iLastFocusedEditor)

   594         {

   595         iLastFocusedEditor->SetObserver(NULL);

   596         iLastFocusedEditor = NULL;

   597         } 

   598     if (iFepAwareDialogParentEditor)

   599         {

   600         iFepAwareDialogParentEditor->SetObserver(NULL);

   601         iFepAwareDialogParentEditor = NULL;

   602         } 

   603     

   604     delete iSharedDataInterface;

   605     MAknEditingStateIndicator* indicator = CAknEnv::Static()->EditingStateIndicator();

   606     if (indicator == iIndicator)

   607         {

   608         CAknEnv::Static()->SwapEditingStateIndicator(NULL);

   609         }

   610 

   611         

   612     delete iIndicator;

   613     iIndicator = NULL;

   614     CCoeEnv::Static()->DeleteResourceFile(iResId);

   615 

   616     // Everything that is constructed in ConstructFullyL() method

   617     // needs to be deleted in CommonDestroyFep() method.

   618     CommonDestroyFep();

   619 

   620 	if (iUiInterface)

   621 	    iUiInterface->SetFepMenuObserver(NULL);

   622 

   623     delete iPtiEngine;

   624     delete iSctEditChars;

   625 

   626 #ifdef RD_SCALABLE_UI_V2

   627     if ( FepAwareTextEditor() )

   628         {

   629     		UnregisterObserver();

   630         }

   631     delete iFepPluginManager;

   632     delete iStylusCcpuMenu;        

   633 

   634     delete iSpellInitText;        

   635 #endif // RD_SCALABLE_UI_V2

   636     delete iUiInterface;

   637 #ifdef RD_INTELLIGENT_TEXT_INPUT

   638     // Predictive QWERTY (XT9) changes ---->

   639     delete iExactWordPopupContent;

   640     iExactWordPopupContent = 0;

   641     delete iCandidatePopup;

   642     iCandidatePopup = 0;

   643     delete iResourceString;

   644     iResourceString = 0;

   645     // Predictive QWERTY (XT9) changes <----

   646 #endif //RD_INTELLIGENT_TEXT_INPUT

   647     // the follow objects for phrase creation

   648       delete iZhuyinKeyHandler;

   649       delete iZhuyinAnalyser;

   650     delete iAknFepThaiSCTSelector;

   651     }

   652 

   653 void CAknFepManager::CommonDestroyFep()

   654     {

   655     iFepFullyConstructed = EFalse;

   656 

   657     // This method is called both from destructor and CleanUpFep methods.

   658     iAsyncOwnSimulateKey.Cancel();

   659     iAsyncResouceChanged.Cancel();

   660     delete iShiftKeypressMonitor;

   661     iShiftKeypressMonitor = NULL;

   662     delete iConcatenationTimer;

   663     iConcatenationTimer = NULL;

   664     delete iChrKeypressMonitor;

   665     iChrKeypressMonitor = NULL;

   666     delete iLangMan;

   667     iLangMan = NULL;

   668     iCurrentFepUI = NULL;

   669     delete iKeyCatcher;

   670     iKeyCatcher = NULL;

   671 

   672     delete iPostEventCheck;

   673     iPostEventCheck = NULL;

   674     delete iHashKeyMan;

   675     iHashKeyMan = NULL;

   676     delete iCaseMan;

   677     iCaseMan = NULL;

   678     delete iInlineTextDecorator;

   679     iInlineTextDecorator = NULL;

   680     iHashKeyLoop.Close();

   681 #ifdef RD_INTELLIGENT_TEXT_INPUT

   682     if(iFnKeyManager)

   683         {

   684         delete iFnKeyManager;

   685         iFnKeyManager = NULL;

   686         }

   687     if( iNumericResourceTimer )        

   688         {

   689         delete iNumericResourceTimer;

   690         iNumericResourceTimer = NULL;    

   691         }

   692 #endif

   693     }

   694 

   695 #ifdef RD_INTELLIGENT_TEXT_INPUT

   696 void CAknFepManager::SetKeyboardLayout(TPtiKeyboardType aType)

   697     {

   698     	

   699     if(iQwertyInputMode && iFnKeyManager 

   700     		&& (iFnKeyManager->FnKeyState()== CAknFepFnKeyManager::EFnKeyLock

   701 		||iFnKeyManager->FnKeyState()== CAknFepFnKeyManager::EFnKeyNext)) 

   702 		{

   703         	iMode = ENumber;

   704 		}

   705 	

   706 	if(iFnKeyManager)        

   707 		{

   708 		iFnKeyManager->ClearFnKeyState();

   709 		}

   710     	

   711     if(iPtiEngine)

   712         {

   713         iPtiEngine->SetKeyboardType(aType);

   714         }    

   715     iKeyboardType = aType;        

   716     }

   717 

   718 TPtiKeyboardType CAknFepManager::KeyboardLayout() const

   719     {

   720     return iKeyboardType;

   721     }

   722 #endif

   723 TBool CAknFepManager::TryCloseUiL()

   724     {

   725 #ifdef RD_HINDI_PHONETIC_INPUT        

   726     if ((iSharedDataInterface->InputTextLanguage() == KLangHindiPhonetic) && 

   727          IsFlagSet(CAknFepManager::EFlagNoMatches))

   728         {

   729         ClearFlag(CAknFepManager::EFlagNoMatches);

   730     	if (PreviousChar() == KQuestionMark)

   731     		RemovePreviousCharacterL();

   732     	}

   733 #endif    

   734     if (iFepManState == EAknFepStateUIActive)

   735         {

   736         // In Japanese input,

   737         // commit inline editing at only the western predictive mode.

   738         if (!IsFeatureSupportedJapanese() || WesternPredictive())

   739             {

   740             if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   741                 {

   742                 TryRemoveNoMatchesIndicatorL();

   743                 UpdateCbaL(NULL);

   744                 }

   745                 

   746              	

   747 

   748 //#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   749 #ifdef RD_INTELLIGENT_TEXT_INPUT

   750             if ( iFepPluginManager && 

   751              	(iFepPluginManager->PluginInputMode() == EPluginInputModeNone))

   752             	{

   753             	RemoveSuggestedAdvanceCompletionL();

   754             	}            

   755 #endif // RD_INTELLIGENT_TEXT_INPUT              

   756 //#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   757                 

   758 #ifdef RD_SCALABLE_UI_V2 

   759             

   760             if ( iFepPluginManager != NULL && 

   761                  iFepPluginManager->BeforeSpell() )

   762                 {

   763                 iFepPluginManager->SetBeforeSpell(EFalse);

   764                 }

   765             else

   766 #endif  

   767           

   768                 {

   769                 CommitInlineEditL();    

   770                 }

   771             }

   772         if (IsCcpuFlagSet(ECcpuStataCommitPredictiveWord))            

   773             {

   774             // Word commiting must be done after CommitInlineEditL call (because

   775             // of Japanese ReadingTextL funtionality), hence the delayed commit here.

   776             iPtiEngine->CommitCurrentWord();

   777             ClearCcpuFlag(ECcpuStataCommitPredictiveWord);

   778             }            

   779         InternalFepUI()->CloseUI();

   780         SyncStates(EAknFepStateInitial);

   781         if (iMode == EPinyin || iMode == EZhuyin || iMode == EStroke || iMode == ECangJie)

   782             {

   783             SetCursorType(EActive);

   784             if ( EditorState() )

   785             	{

   786             	EditorState()->SetFlags( EditorState()->Flags() & ~EAknEditorFlagChinesePopup );

   787             	}            

   788             }

   789 

   790         // EFalse in case of latin input in Japanese variant

   791         if (IsFeatureSupportedJapanese() 

   792          && iMode == ELatin && !WesternPredictive())

   793             {

   794             return EFalse;

   795             }

   796 

   797         return ETrue;

   798         }

   799     else

   800         {

   801     	if (IsKoreanInputLanguage())

   802         	{

   803         	if (IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

   804         		{

   805         	   	CommitInlineEditL();

   806         		PtiEngine()->ClearCurrentWord();

   807         		}

   808         	}

   809     	

   810         //in initial state characters should either:

   811         //1. not be consumed by the FEP.

   812         //2. be committed immediately by the Input State.

   813         //3. be multitap chars, in which case they may need to be committed

   814         // here. It is best to let the engine deal with this.

   815         if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

   816             {

   817             InternalFepUI()->ExpireMultitapTimer();

   818             }

   819         return EFalse;

   820         }

   821     }

   822 

   823 void CAknFepManager::SendUIActivatedNotification()

   824     {

   825     SyncStates(EAknFepStateUIActive);

   826     }

   827 

   828 void CAknFepManager::SendUIDeActivatedNotification()

   829     {

   830     SyncStates(EAknFepStateInitial);

   831     }

   832 

   833 void CAknFepManager::PlaySound(TAvkonSystemSID aSound) const

   834     {

   835     if (SoundSystem())

   836         {

   837         SoundSystem()->PlaySound(aSound);

   838         }

   839     }

   840     

   841 void CAknFepManager::SetLongClearAfterCloseUI(TBool aLongClear)

   842     {

   843     iLongClearAfterCloseUI = aLongClear;

   844     }

   845 

   846 TKeyResponse CAknFepManager::HandleKeyEventL(TUint aCode, TKeyPressLength aLength,TEventCode aEventCode)

   847     {

   848     TKeyResponse response = EKeyWasNotConsumed;

   849 

   850     TInt documentLength = -1;

   851     if (iInputCapabilities.FepAwareTextEditor())

   852         {

   853         documentLength = iInputCapabilities.FepAwareTextEditor()->DocumentLengthForFep();

   854         }

   855 

   856     if (iFepFullyConstructed && iConcatenationTimer->IsActive())

   857         {

   858         if (!( aCode == EKeyRightArrow ||

   859              aCode == EKeyLeftArrow ||

   860              aCode == EKeyUpArrow ||

   861              aCode == EKeyDownArrow ))

   862             {

   863             iConcatenationTimer->Cancel();

   864             }

   865         }

   866 

   867 #ifdef RD_INTELLIGENT_TEXT_INPUT    

   868     

   869     if(iKeyBackSpaceHit && aCode != EKeyBackspace)

   870     	iKeyBackSpaceHit = 0;

   871     

   872     if (aCode != EPtiKeyStar && iNumericResourceTimer)

   873         {

   874         // return with EKeyWasConsumed if any of the arrow keys are pressed with 

   875         // iNumericResourceTimer is active

   876         if(NumericResourceMultiTapTimerTimeoutL()&&

   877            (aCode == EKeyRightArrow || aCode == EKeyLeftArrow || aCode == EKeyUpArrow || aCode ==EKeyDownArrow))

   878             return EKeyWasConsumed;

   879         }

   880 #endif

   881 

   882 

   883 

   884     // This method is implemented independent of all modes, so it can be called by anyone, anywhere

   885     if ( BidiCursorRequired() )

   886         {

   887         response = AttemptCursorFlipAtAmbiguousPointL( aCode );

   888         if ( response == EKeyWasConsumed )

   889             {

   890             return response;

   891             }

   892         }

   893 

   894     if ( aCode != EPtiKeyHash 

   895 #ifdef RD_INTELLIGENT_TEXT_INPUT

   896 #ifdef __HALF_QWERTY_KEYPAD

   897 #ifdef __SHIFT_KEY_LOOP		

   898     		&& ( aCode != EPtiKeyQwertyLeftShift 

   899     		|| EPtiKeyboardHalfQwerty != KeyboardLayout() )

   900 #endif //__SHIFT_KEY_LOOP

   901 #endif //__HALF_QWERTY_KEYPAD

   902 #endif //RD_INTELLIGENT_TEXT_INPUT   		

   903     		)

   904     

   905         {

   906         

   907         SetLastPressedHashKeyStatus(EFalse);

   908         

   909         if(iHashKeyMan)

   910             {

   911             iHashKeyMan->CancelHashKeyTimer();

   912             if (aCode != EKeyOK)

   913                 {

   914                 iHashKeyMan->ClearSelectionModeHashKeyLoop();

   915                 }

   916             }

   917         }

   918     // Always commit the text before handling arrow keys

   919     if (iMode == EHangul && IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

   920     	{

   921     	if ( aCode == EKeyRightArrow ||

   922              aCode == EKeyLeftArrow ||

   923              aCode == EKeyUpArrow ||

   924              aCode == EKeyDownArrow )

   925     		{

   926     		CommitInlineEditL();

   927        		iPtiEngine->ClearCurrentWord();

   928     		}

   929         }

   930     TBool isPassNext = IsFlagSet(EFlagPassNextKey);

   931    

   932     switch (aCode)

   933         {

   934         case EKeyEscape:

   935 

   936 #ifdef RD_SCALABLE_UI_V2     

   937         if( iFepFullyConstructed && iFepPluginManager)

   938             {

   939             iFepPluginManager->ResetMenuState(EFalse);            

   940             }

   941 #endif         

   942             if (TryCloseUiL())

   943                 {

   944                 response = EKeyWasConsumed;

   945                 // phrase creation

   946                 PhraseCreation(EFalse);

   947                 // phrase creation

   948                 PinyinPhraseCreation(EFalse);

   949                 }

   950             break;

   951 #ifdef RD_INTELLIGENT_TEXT_INPUT

   952 #ifdef __HALF_QWERTY_KEYPAD

   953 #ifdef __SHIFT_KEY_LOOP

   954         case EPtiKeyQwertyLeftShift:

   955         if( EPtiKeyboardHalfQwerty == KeyboardLayout() )

   956         	{

   957 			response = HandleHashKeyL(aLength);

   958             (aLength == ELongKeyPress)? SetLastPressedHashKeyStatus(EFalse):SetLastPressedHashKeyStatus(ETrue);

   959 			}

   960             break;			

   961 #endif //__SHIFT_KEY_LOOP       	

   962 #endif //__HALF_QWERTY_KEYPAD	

   963 #endif //RD_INTELLIGENT_TEXT_INPUT

   964         case EPtiKeyHash:

   965             if(InputMode() == EHangul)

   966             	{

   967 				if (aLength == EShortKeyPress)

   968 					{

   969 					FepUI()->HandleKeyL(aCode, aLength);

   970 					response = EKeyWasConsumed;

   971 					}

   972 				else

   973 					{

   974                	 	//PhraseCreation(EFalse);

   975             		response = HandleHashKeyL(aLength);

   976             		(aLength == ELongKeyPress)? SetLastPressedHashKeyStatus(EFalse):

   977                                         		SetLastPressedHashKeyStatus(ETrue);

   978 					}

   979 				}

   980      	     else if (InputMode()!= EZhuyin)

   981                 {

   982                 if (IsPinyinPhraseCreation() )

   983                     {

   984                     ClearCcpuFlag( ECcpuStateHashDown );

   985                     response = EKeyWasConsumed;

   986                     }

   987                 else

   988                     {

   989                     response = HandleHashKeyL(aLength);

   990                     (aLength == ELongKeyPress)

   991                         ? SetLastPressedHashKeyStatus(EFalse)

   992                             : SetLastPressedHashKeyStatus(ETrue);

   993                     }

   994                 }

   995             else

   996                 {

   997                 PhraseCreation(EFalse);

   998                 response = HandleHashKeyL(aLength);

   999                 (aLength == ELongKeyPress)

  1000                     ? SetLastPressedHashKeyStatus(EFalse)

  1001                         : SetLastPressedHashKeyStatus(ETrue);

  1002                 }

  1003             break;

  1004         case EKeyCBA1:

  1005             if(Japanese())

  1006                 {

  1007                 if (FepUI()->HandleKeyL(aCode, aLength))

  1008                     {

  1009                     response = EKeyWasConsumed;

  1010                     }

  1011                 break;

  1012                 }

  1013             // phrase creation the key CBA2 need to solve.

  1014             if ( IsEntryPhrase() )

  1015                 {

  1016                 if ( FepUI()->HandleKeyL( aCode, aLength ) )

  1017                     {

  1018                     response = EKeyWasConsumed;

  1019                     break;

  1020                     }

  1021                 }

  1022 

  1023             if (!WesternPredictive())

  1024                 {

  1025                 if (TryCloseUiL())

  1026                     {

  1027                     response = EKeyWasConsumed;

  1028                     }

  1029                 }            

  1030             break;

  1031         case EKeyCBA2:

  1032             if(Japanese())

  1033                 {

  1034                 if (FepUI()->HandleKeyL(aCode, aLength))

  1035                     {

  1036                     response = EKeyWasConsumed;

  1037                     }

  1038                 break;

  1039                 }

  1040             if (!WesternPredictive())

  1041                 {

  1042                 if (TryCloseUiL())

  1043                     {

  1044                     // phrase creation the key CBA2 need to solve.

  1045                     PhraseCreation( EFalse );

  1046                     response = EKeyWasConsumed;

  1047                     }

  1048                 }

  1049      		 else

  1050                 {

  1051                 if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

  1052                     {

  1053                     InternalFepUI()->ExpireMultitapTimer();

  1054                     }

  1055                 }

  1056             // phrase creation the key CBA2 need to solve.

  1057             EntryPhrase( EFalse );

  1058             break;

  1059         case EPtiKeyStar:

  1060             if (IsFlagSet(EFlagPassNextKey))

  1061                 {

  1062                 ClearFlag(EFlagPassNextKey);

  1063                 }

  1064             else if ( !IsFepAwareTextEditor() )

  1065                 {

  1066                 // The editor is MFNE or other non FEP aware text editor.

  1067                 // Pass the key to the editor to handle.

  1068                 response = EKeyWasNotConsumed;

  1069                 }

  1070             else if (IsFlagSet(EFlagShiftKeyDepressed))

  1071                 {

  1072                 response = EKeyWasConsumed;

  1073                 }

  1074             else 

  1075                 {

  1076 #ifdef RD_SCALABLE_UI_V2                

  1077                 iStarKeyPressed = ETrue;

  1078 #endif // RD_SCALABLE_UI_V2                    

  1079                 if (FepUI()->HandleKeyL(aCode, aLength, aEventCode))

  1080                     {

  1081                     response = EKeyWasConsumed;

  1082                     }

  1083 #ifdef RD_SCALABLE_UI_V2                

  1084                 iStarKeyPressed = EFalse;

  1085 #endif // RD_SCALABLE_UI_V2                     

  1086                 }

  1087             break;

  1088         case EKeyRightArrow:

  1089             if (TryHandleArrowRightEventL(documentLength))

  1090                 {

  1091                 response = EKeyWasConsumed;

  1092                 break;

  1093                 }

  1094             // fall through

  1095         case EKeyLeftArrow:

  1096             if (aCode == EKeyLeftArrow && TryHandleArrowLeftEventL(documentLength))

  1097                 {

  1098                 response = EKeyWasConsumed;

  1099                 break;

  1100                 }

  1101                 

  1102             if (IsCcpuFlagSet(ECcpuStateCopy | ECcpuStateCut))    

  1103                 {

  1104                 response = EKeyWasNotConsumed;

  1105                 break;

  1106                 }            

  1107             else if (IsCcpuFlagSet(ECcpuStateStartCopy | ECcpuStateStartCut))    

  1108                 {

  1109                 TryHandleCommonArrowAndBackspaceFunctionalityL(aCode, response);                

  1110                 break;

  1111                 }               

  1112 

  1113             if (iLanguageCapabilities.iInputLanguageCode == ELangJapanese && iMode != ELatin)

  1114                 {

  1115                 if(FepUI()->HandleKeyL(aCode, aLength))

  1116                     {

  1117                     response = EKeyWasConsumed;

  1118                     }

  1119                 }

  1120             else

  1121                 {

  1122                 if (WesternPredictive())

  1123                     {

  1124                     response = HandleWesternPredictiveArrowKeyL(aCode, aLength);

  1125                     }

  1126                 else

  1127                     {

  1128                     if (iFepManState == EAknFepStateUIActive)

  1129                         {

  1130                         FepUI()->HandleKeyL(aCode, aLength);

  1131                         response = EKeyWasConsumed;

  1132                         }

  1133                     else

  1134                         {