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 <peninputgsinterface.h>

    93 #include <aknextendedinputcapabilities.h>

    94 #include <AvkonInternalCRKeys.h>

    95 #include <hlplch.h>

    96 #include <aknfepdocumentnavigation.h>

    97 

    98 #include <eikcolib.h>

    99 #include <akntoolbar.h>

   100 

   101 #include <eikfrlbd.h>

   102 #include <eikccpu.h>

   103 #include <aknappui.h>

   104 #include <apgwgnam.h>

   105 #ifdef RD_INTELLIGENT_TEXT_INPUT

   106 #include "AknFepUiWordPopupContent.h"

   107 #include "AknFepFnKeyManager.h"

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

   109 #endif //RD_INTELLIGENT_TEXT_INPUT

   110 

   111 #ifdef RD_TACTILE_FEEDBACK

   112 #include <touchfeedback.h>

   113 #endif //RD_TACTILE_FEEDBACK

   114 #include "AknFepThaiSCTSelector.h"

   115 

   116 //the follow 10 filse include for phrase creation

   117 #include <bamdesca.h>

   118 #include <eikspane.h> //CEikStatusPane 

   119 #include <akntitle.h> //CAknTitlePane 

   120 #include <akntoolbar.h> //CAknToolBar 

   121 #include <aknappui.h>

   122 #include "AknFep.hrh"

   123 #include "aknfepuserdbdlg.h"

   124 #include "aknfepzhuyinkeyhandler.h"

   125 #include "AknFepZhuyinAnalyser.h"

   126 #include "AknFepZhuyinAnalyserDb.h"

   127 

   128 #include <aknnavi.h> 

   129 #include <aknnavide.h> 

   130 

   131 #include <eikedwin.h>

   132 #include <aknCharMap.h>

   133 

   134 #include <AknFepInternalPSKeys.h>

   135 #include <e32property.h>

   136 #include <AknDef.h>

   137 

   138 const TInt KSelectItemSize(10);

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

   140 

   141 #define text_to_field_mode_hash_key ';'

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

   143 #define __SHIFT_KEY_LOOP

   144 

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

   146 #define EAknEditorNativeKeysNumberModeKeymap EAknEditorReservedInternalUseKeymap

   147 

   148 // UID of user dictionary application

   149 const TUid KUidUserDictApp = {0x101F8645};

   150 

   151 const TText KAknFEPLineFeedSymbol = 0x21B2;

   152 const TText KAknFEPMirroredLineFeedSymbol = 0x21B3;

   153 const TText KAknFEPZeroKey = 0x30;

   154 

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

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

   157 

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

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

   160 // a single line of text

   161 const TInt KMaxChunkWalkIterations(20);

   162 

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

   164 const TInt KNullCommandId = 0;

   165 

   166 _LIT_SECURE_ID(KPhoneSecureId, 0x100058b3);

   167 

   168 #ifdef RD_HINDI_PHONETIC_INPUT

   169 

   170 const TUint KQuestionMark = 0x003F;

   171 

   172 #endif

   173 

   174 // Ccpu key events. 

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

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

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

   178 */

   179 

   180 const TInt KTouchInputPreviewOn = 1;

   181 const TInt KTouchInputPreviewOff = 0;

   182 

   183 #ifdef  RD_SCALABLE_UI_V2

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

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

   186 

   187 const TInt KMaxMenuSize = 28;

   188 const TInt KEditorMenuPermitedSend[KMaxMenuSize] = 

   189     {         

   190     EJapanFepCmdModeHiragana,

   191     EJapanFepCmdModeKatakana,

   192     EJapanFepCmdEditModeAlpha,

   193     EJapanFepCmdEditModeNumber,

   194     EJapanFepCmdModeFullWidth,

   195     EJapanFepCmdModeHalfWidth,

   196     EChinFepCmdModePinyin,

   197     EChinFepCmdModeZhuyin,

   198     EChinFepCmdModeStroke,

   199     EChinFepCmdModePinyinPhrase,

   200     EChinFepCmdModeZhuyinPhrase,

   201     EChinFepCmdModeStrokePhrase,    

   202     EAknCmdT9PredictiveT9Off,

   203     EAknCmdMultitapPredictiveT9On,

   204     EJapanFepCmdMultitapPredictiveT9On,

   205     EChinFepCmdModeZhuyinFind,

   206     EChinFepCmdModeStrokeFind,

   207     EAknCmdEditModeAlpha,

   208     EAknCmdEditModeLatinText,

   209     EChinFepCmdModeLatinUpper,

   210     EChinFepCmdModeLatinLower,

   211     EAknCmdEditModeNumber,

   212     EChinFepCmdModeNumber,

   213     EAknCmdEditModeArabicIndicNumber,

   214     EAknCmdEditModeEasternArabicIndicNumber,

   215     EAknCmdEditModeIndicNumber,

   216     EAknCmdEditModeKorean,

   217     EAknCmdEditModeEnglish

   218     };   

   219      

   220 #endif // RD_SCALABLE_UI_V2 

   221 

   222 

   223 // Number modes used by Arabic or Hindi.

   224 enum TNonLatinNumberModes

   225     { 

   226     ENbrModeLatin,

   227     ENbrModeArabic = 1,

   228     ENbrModeIndic = 1

   229     };

   230 

   231 // Number mode type

   232 enum TNonLatinNumberModeType

   233     {

   234     ENbrModeTypeArabic,

   235     ENbrModeTypeIndic,

   236     ENbrModeTypeEasternArabic //for Urdu & Farsi languages

   237     };

   238     

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

   240 const TInt KSyncPasswdTimeout = 1000000;

   241 

   242 #ifdef RD_SCALABLE_UI_V2

   243 TUid AppUidFromWndGroupId(TInt aWndGrpId);

   244 extern TUid GetCurAppUid();

   245 extern TBool IsGlobalNotesApp(TUid& aUid);

   246 TInt GetForegroundTaskAppWgId();

   247 #endif

   248 #ifdef RD_INTELLIGENT_TEXT_INPUT

   249 const TInt KWordToFocusInCandidateList = 1;

   250 #endif

   251 

   252 LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

   253 

   254 //

   255 // Class TTextDirectionalInfo

   256 //

   257 /**

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

   259 */

   260 CAknFepManager::TTextDirectionalInfo::TTextDirectionalInfo() : 

   261 iDirectionalStatus(EUnknown), iBlockEnvironment(EUndefined)

   262     {}

   263 

   264 void CAknFepManager::TTextDirectionalInfo::SetDirectionFromChunk( 

   265                const CTmTextLayout::TTmChunkDescription& aChunk )

   266     {

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

   268         iDirectionalStatus = aChunk.iRightToLeft ? ERightToLeft : ELeftToRight;

   269     }

   270 

   271 

   272 void TFepLanguageTranslation::ReadFromResource(TResourceReader& aReader)

   273     {

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

   275     iLanguageId = aReader.ReadInt16();

   276     iCommandId = aReader.ReadInt16();

   277     }

   278 

   279 

   280 CAknFepManager::CAknFepManager(CCoeEnv& aConeEnvironment)

   281     :CCoeFep(aConeEnvironment),

   282     iAsyncResouceChanged(EActivePriorityDefault),

   283     iPreviousEditingState(EStateNone),

   284     iInputCapabilities(TCoeInputCapabilities::ENone),

   285     iModeBefore(ELatin),

   286     #ifdef RD_INTELLIGENT_TEXT_INPUT

   287     iKeyPressedDuringShift(EFalse),

   288 #endif

   289     iCharWidth(EHalfWidthChar),

   290     iAsyncOwnSimulateKey(EActivePriorityDefault),

   291     iLongThai0Key(EFalse),

   292     iEditCharsPtr(0,0),

   293     iComposChrFlag(0),

   294     iIsUserdbdlgActive(0),

   295     iLongClearAfterCloseUI(EFalse),

   296     // phrase creation

   297     iPhraseCreation(0),

   298     iPinyinPhraseCreation(0),

   299     iEntryPhrase(0)

   300     

   301 

   302     {

   303     }

   304 

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

   306     {

   307     BaseConstructL(aFepParameters);

   308     iUiInterface = CAknFepUIInterface::NewL();

   309     iIndicator = iUiInterface->NewIndicatorL();

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

   311 

   312     // Set up resources

   313     TFileName resourceName(KAknFepResourceFileName);

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

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

   316     iResId = coeEnv->AddResourceFileL(resourceName);

   317 

   318     // Save Japanese Feature support to a member variable

   319     iFeatureSupportedJapanese = FeatureManager::FeatureSupported(KFeatureIdJapanese);

   320 

   321     iUiLanguage = User::Language();

   322     

   323     // Shared Data

   324     iSharedDataInterface = CAknFepSharedDataInterface::NewL(this);

   325 

   326     TInt previUiLanguage = iSharedDataInterface->PluginUILanguage();

   327 

   328     if (iUiLanguage != previUiLanguage)

   329         {

   330         

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

   332         iSharedDataInterface->SetPluginUILanguage(iUiLanguage);

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

   334         }

   335 

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

   337         {

   338         switch (iUiLanguage)

   339             {

   340             case ELangPrcChinese:

   341                 iSharedDataInterface->SetInputMode(EPinyin);

   342                 break;

   343             case ELangTaiwanChinese:

   344                 iSharedDataInterface->SetInputMode(EZhuyin);

   345                 break;

   346             case ELangHongKongChinese:

   347                 iSharedDataInterface->SetInputMode(EStroke);

   348                 iSharedDataInterface->SetCangJieMode(ECangJieNormal);

   349                 break;

   350             case ELangJapanese:

   351                 iSharedDataInterface->SetInputMode(EHiraganaKanji);

   352                 break;

   353             case ELangKorean:

   354                 iSharedDataInterface->SetInputMode(EHangul);

   355                 break;

   356             case ELangHindi:

   357                 iSharedDataInterface->SetInputMode(EHindi);

   358                 break;

   359             default:

   360                 iSharedDataInterface->SetInputMode(ELatin);

   361                 break;

   362             }

   363         }

   364 

   365     iUiInterface->SetFepMenuObserver(this);

   366    

   367     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   368 

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

   370     // which is needed for updating locale repository.

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

   372     TSecurityInfo info;

   373     info.Set(RProcess());

   374 

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

   376     

   377     if (!inputLanguage && hasCapability)

   378         {

   379         // set correct input language

   380         inputLanguage = SubstituteSublanguageId(iUiLanguage);

   381         

   382         // If Ptiengine is not initialize, initialize it

   383         if (!iPtiEngine)

   384             {

   385             iPtiEngine = CPtiEngine::NewL(ETrue);    

   386             }         

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

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

   389             {

   390             inputLanguage = ELangEnglish;   

   391             }

   392         

   393         // Set the current input language

   394         iSharedDataInterface->SetInputTextLanguage(inputLanguage);

   395         

   396         // update numeric input

   397         if ( iUiLanguage == ELangArabic ) 

   398             {

   399             SetDefaultNumberMode( ENbrModeArabic, 

   400                                   ENbrModeTypeArabic );

   401             }            

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

   403                   ( iUiLanguage == ELangFarsi  ) )

   404             {

   405             SetDefaultNumberMode( ENbrModeArabic, 

   406                                   ENbrModeTypeEasternArabic );

   407             }

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

   409             {

   410             SetDefaultNumberMode( ENbrModeLatin, 

   411                                   ENbrModeTypeIndic );

   412             }

   413         else

   414             {           

   415             SetDefaultNumberMode( ENbrModeLatin, ENbrModeTypeArabic );

   416             }

   417         }

   418         

   419     iSctEditChars = HBufC::NewL( 10 );

   420     

   421 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

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

   424 				iExactWordPopupContent = iUiInterface->CreateWordPopupContentL();

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

   426 #endif //RD_INTELLIGENT_TEXT_INPUT

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

   428     // for all applications at application startup.

   429     // ConstructFullyL();

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

   431 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   433 #endif

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

   435     if(result == KErrNone)

   436         {

   437         iKeyCatcher->ActivateL();

   438         }

   439     // the follow 3 objects for phrase creation

   440     iZhuyinKeyHandler = CZhuyinKeyHandler::NewL();

   441     iZhuyinAnalyserDb = CZhuyinAnalyserDbFeed::NewL(EPinyinAnalyserTypeZhuyin);

   442     iZhuyinAnalyser = CAknFepZhuyinAnalyser::NewL(iZhuyinAnalyserDb);

   443     iAknFepThaiSCTSelector = CAknFepThaiSCTSelector::NewL();

   444     iHybridAplphaChangedToAlphanumeric = EFalse;

   445     iLastFocusedEditor = NULL;

   446     iFepAwareDialogParentEditor = NULL;

   447 	

   448     // Fep manager should have both read and write privilege.

   449     // Known case: Auto-completion cannot be changed in setting dialog.

   450     RProperty::Define( KPSUidAknFep, KAknFepSettingDialogState, RProperty::EInt );

   451     }

   452 

   453 void CAknFepManager::ConstructFullyL()

   454     {

   455     if (!iPtiEngine)

   456         {

   457         iPtiEngine = CPtiEngine::NewL(ETrue);    

   458         } 

   459     

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

   461         {

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

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

   464         TInt inputLang = SubstituteSublanguageId(iUiLanguage);

   465         

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

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

   468             {

   469             inputLang = ELangEnglish;   

   470             }

   471         iSharedDataInterface->SetInputTextLanguage(inputLang);      

   472         }      

   473 #ifdef RD_INTELLIGENT_TEXT_INPUT

   474 #ifdef FF_DUAL_LANGUAGE_SUPPORT

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

   476         {

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

   478         iSharedDataInterface->SetInputTextLanguageSecondary(0);

   479         }

   480 #endif //FF_DUAL_LANGUAGE_SUPPORT

   481 #endif

   482         

   483     if(NULL == iKeyCatcher)

   484         {

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

   486         iKeyCatcher->ActivateL();

   487         }

   488     

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

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

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

   492 

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

   494     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   495 #ifdef RD_INTELLIGENT_TEXT_INPUT

   496 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   497     TInt inputLanguageSecondary = iSharedDataInterface->InputTextLanguageSecondary();

   498 #endif //FF_DUAL_LANGUAGE_SUPPORT

   499 #endif

   500     SetWesternPredictive(iSharedDataInterface->PredictiveTextOn());

   501 #ifndef RD_INTELLIGENT_TEXT_INPUT

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

   503 #endif	//RD_INTELLIGENT_TEXT_INPUT

   504 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   506     iTypingCorrectionLevel = iSharedDataInterface->PredictiveTextTypingCorrectionLevel();

   507     iIsNumberCandidateShown = iSharedDataInterface->PredictiveTextNumberCandidateShown();

   508     TInt primaryCandidateValue = iSharedDataInterface->PredictiveTextPrimaryCandidate();

   509     if( primaryCandidateValue == 0)

   510 		iPrimaryCandidate = ETrue;

   511 	else if(primaryCandidateValue == 1)

   512 		iPrimaryCandidate = EFalse; 

   513 #endif // RD_INTELLIGENT_TEXT_INPUT

   514     iJapanesePredictive = iSharedDataInterface->PredictiveTextJapaneseOn();

   515     iQwertyInputMode = iSharedDataInterface->QwertyInputMode();

   516     iMultiTapTimer = iSharedDataInterface->MultiTapTimer();

   517     iJapaneseQwertyFlags = iSharedDataInterface->JapaneseQwertyFlags();

   518 #ifdef RD_INTELLIGENT_TEXT_INPUT

   519     if(!iFnKeyManager)

   520         {

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

   522         }    

   523 #endif

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

   525     iLangMan = CAknFepLanguageManager::NewL( this, iCaseMan, iSharedDataInterface );

   526     iPtiEngine->ActivateLanguageL(inputLanguage);

   527 #ifdef RD_INTELLIGENT_TEXT_INPUT

   528 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   529     iPtiEngine->SetSecondaryInputL(inputLanguageSecondary);

   530 #endif //FF_DUAL_LANGUAGE_SUPPORT

   531 #endif

   532     iLangMan->SetInputLanguageL(inputLanguage);

   533     SetInputLanguageCapabilities(inputLanguage);

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

   535 

   536     iLastKeyPressedWasHashKey = EFalse;

   537     iDeviceSupportsRtlLanguage = DeviceSupportsRTLLanguageL();

   538 

   539     TResourceReader reader;

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

   541     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_SPACE_SYMBOL);

   542     iSpaceCharacterCode = reader.ReadUint16();

   543     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_FULLWIDTHSPACE_SYMBOL);

   544     iFullWidthSpaceCharacterCode = reader.ReadUint16();

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

   546 

   547     //initialise states

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

   549     SyncStates(EAknFepStateNull);

   550     ResetFlags();

   551     ResetExtendedFlags();

   552 

   553     ReadHashKeyLoopL();

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

   555     SetHashKeyStyle();

   556     iInlineTextDecorator = new (ELeave) CAknFepInlineTextDecorator;

   557     if (IsFeatureSupportedJapanese())

   558         {

   559         CAknJapaneseReading::CreateL(iPtiEngine);

   560         }

   561     // setting call back

   562     TCallBack callback(DoSimulateKey, this);

   563     iAsyncOwnSimulateKey.Set(callback);

   564     

   565     TCallBack resourcechangedcallback(HandleResourceChangedCallback,this);

   566     iAsyncResouceChanged.Set(resourcechangedcallback);

   567 #ifdef RD_SCALABLE_UI_V2

   568     iFepPluginManager = CAknFepPluginManager::NewL

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

   570     iNotifyPlugin = ETrue;

   571 #endif //RD_SCALABLE_UI_V2

   572 

   573     iFepFullyConstructed = ETrue;

   574 #ifdef RD_INTELLIGENT_TEXT_INPUT

   575     iIsFnKeyMapped = IsFnKeyMappedL();

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

   577 #endif

   578     

   579     iFnKeypressMonitor = CPeriodic::NewL(CActive::EPriorityStandard);

   580     }

   581 

   582 CAknFepManager::~CAknFepManager()

   583     {

   584 #ifdef RD_PF_SEC_APPARC

   585     delete iNullService;

   586 #else

   587     //Embedding - removing created document

   588     if ( iEmbedded )

   589         {

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

   591         iEmbedded = NULL;

   592         }

   593 #endif

   594     if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   595         {

   596         SetFlag(CAknFepManager::EFlagSupressAutoUpdate);

   597         TRAPD(err, CommitInlineEditL())

   598         if (err)

   599             {

   600             CleanUpFep();

   601             }

   602         }

   603         

   604     if ( EditorState() )

   605         {

   606         EditorState()->SetObserver(NULL);    

   607         }        

   608     if (iLastFocusedEditor)

   609         {

   610         iLastFocusedEditor->SetObserver(NULL);

   611         iLastFocusedEditor = NULL;

   612         } 

   613     if (iFepAwareDialogParentEditor)

   614         {

   615         iFepAwareDialogParentEditor->SetObserver(NULL);

   616         iFepAwareDialogParentEditor = NULL;

   617         } 

   618     

   619     delete iSharedDataInterface;

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

   621     if (indicator == iIndicator)

   622         {

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

   624         }

   625 

   626         

   627     delete iIndicator;

   628     iIndicator = NULL;

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

   630 

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

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

   633     CommonDestroyFep();

   634 

   635 	if (iUiInterface)

   636 	    iUiInterface->SetFepMenuObserver(NULL);

   637 

   638     delete iPtiEngine;

   639     delete iSctEditChars;

   640 

   641 #ifdef RD_SCALABLE_UI_V2

   642     if ( FepAwareTextEditor() )

   643         {

   644     		UnregisterObserver();

   645         }

   646     delete iFepPluginManager;

   647     delete iStylusCcpuMenu;        

   648 

   649     delete iSpellInitText;        

   650 #endif // RD_SCALABLE_UI_V2

   651     delete iUiInterface;

   652 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   654     delete iExactWordPopupContent;

   655     iExactWordPopupContent = 0;

   656     delete iCandidatePopup;

   657     iCandidatePopup = 0;

   658     delete iResourceString;

   659     iResourceString = 0;

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

   661 #endif //RD_INTELLIGENT_TEXT_INPUT

   662     // the follow objects for phrase creation

   663       delete iZhuyinKeyHandler;

   664       delete iZhuyinAnalyser;

   665     delete iAknFepThaiSCTSelector;

   666     }

   667 

   668 void CAknFepManager::CommonDestroyFep()

   669     {

   670     iFepFullyConstructed = EFalse;

   671 

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

   673     iAsyncOwnSimulateKey.Cancel();

   674     iAsyncResouceChanged.Cancel();

   675     delete iShiftKeypressMonitor;

   676     iShiftKeypressMonitor = NULL;

   677     delete iConcatenationTimer;

   678     iConcatenationTimer = NULL;

   679     delete iChrKeypressMonitor;

   680     iChrKeypressMonitor = NULL;

   681     delete iLangMan;

   682     iLangMan = NULL;

   683     iCurrentFepUI = NULL;

   684     delete iKeyCatcher;

   685     iKeyCatcher = NULL;

   686 

   687     delete iPostEventCheck;

   688     iPostEventCheck = NULL;

   689     delete iHashKeyMan;

   690     iHashKeyMan = NULL;

   691     delete iCaseMan;

   692     iCaseMan = NULL;

   693     delete iInlineTextDecorator;

   694     iInlineTextDecorator = NULL;

   695     iHashKeyLoop.Close();

   696 #ifdef RD_INTELLIGENT_TEXT_INPUT

   697     if(iFnKeyManager)

   698         {

   699         delete iFnKeyManager;

   700         iFnKeyManager = NULL;

   701         }

   702     if( iNumericResourceTimer )        

   703         {

   704         delete iNumericResourceTimer;

   705         iNumericResourceTimer = NULL;    

   706         }

   707 #endif

   708     delete iFnKeypressMonitor;

   709     iFnKeypressMonitor = NULL;

   710     }

   711 

   712 #ifdef RD_INTELLIGENT_TEXT_INPUT

   713 void CAknFepManager::SetKeyboardLayout(TPtiKeyboardType aType)

   714     {

   715     	

   716     if(iQwertyInputMode && iFnKeyManager 

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

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

   719 		{

   720         	iMode = ENumber;

   721 		}

   722 	

   723 	if(iFnKeyManager)        

   724 		{

   725 		iFnKeyManager->ClearFnKeyState();

   726 		}

   727     	

   728     if(iPtiEngine)

   729         {

   730         iPtiEngine->SetKeyboardType(aType);

   731         }    

   732     iKeyboardType = aType;        

   733     }

   734 

   735 TPtiKeyboardType CAknFepManager::KeyboardLayout() const

   736     {

   737     return iKeyboardType;

   738     }

   739 #endif

   740 TBool CAknFepManager::TryCloseUiL()

   741     {

   742 #ifdef RD_HINDI_PHONETIC_INPUT        

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

   744          IsFlagSet(CAknFepManager::EFlagNoMatches))

   745         {

   746         ClearFlag(CAknFepManager::EFlagNoMatches);

   747     	if (PreviousChar() == KQuestionMark)

   748     		RemovePreviousCharacterL();

   749     	}

   750 #endif    

   751     if (iFepManState == EAknFepStateUIActive)

   752         {

   753         // In Japanese input,

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

   755         if (!IsFeatureSupportedJapanese() || WesternPredictive())

   756             {

   757             if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   758                 {

   759                 TryRemoveNoMatchesIndicatorL();

   760                 UpdateCbaL(NULL);

   761                 }

   762                 

   763              	

   764 

   765 //#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   766 #ifdef RD_INTELLIGENT_TEXT_INPUT

   767             if ( iFepPluginManager && 

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

   769             	{

   770             	RemoveSuggestedAdvanceCompletionL();

   771             	}            

   772 #endif // RD_INTELLIGENT_TEXT_INPUT              

   773 //#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   774                 

   775 #ifdef RD_SCALABLE_UI_V2 

   776             

   777             if ( iFepPluginManager != NULL && 

   778                  iFepPluginManager->BeforeSpell() )

   779                 {

   780                 iFepPluginManager->SetBeforeSpell(EFalse);

   781                 }

   782             else

   783 #endif  

   784           

   785                 {

   786                 CommitInlineEditL();    

   787                 }

   788             }

   789         if (IsCcpuFlagSet(ECcpuStataCommitPredictiveWord))            

   790             {

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

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

   793             iPtiEngine->CommitCurrentWord();

   794             ClearCcpuFlag(ECcpuStataCommitPredictiveWord);

   795             }            

   796         InternalFepUI()->CloseUI();

   797         SyncStates(EAknFepStateInitial);

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

   799             {

   800             SetCursorType(EActive);

   801             if ( EditorState() )

   802             	{

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

   804             	}            

   805             }

   806 

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

   808         if (IsFeatureSupportedJapanese() 

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

   810             {

   811             return EFalse;

   812             }

   813 

   814         return ETrue;

   815         }

   816     else

   817         {

   818     	if (IsKoreanInputLanguage())

   819         	{

   820         	if (IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

   821         		{

   822         	   	CommitInlineEditL();

   823         		PtiEngine()->ClearCurrentWord();

   824         		}

   825         	}

   826     	

   827         //in initial state characters should either:

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

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

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

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

   832         if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

   833             {

   834             InternalFepUI()->ExpireMultitapTimer();

   835             }

   836         return EFalse;

   837         }

   838     }

   839 

   840 void CAknFepManager::SendUIActivatedNotification()

   841     {

   842     SyncStates(EAknFepStateUIActive);

   843     }

   844 

   845 void CAknFepManager::SendUIDeActivatedNotification()

   846     {

   847     SyncStates(EAknFepStateInitial);

   848     }

   849 

   850 void CAknFepManager::PlaySound(TAvkonSystemSID aSound) const

   851     {

   852     if (SoundSystem())

   853         {

   854         SoundSystem()->PlaySound(aSound);

   855         }

   856     }

   857     

   858 void CAknFepManager::SetLongClearAfterCloseUI(TBool aLongClear)

   859     {

   860     iLongClearAfterCloseUI = aLongClear;

   861     }

   862 

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

   864     {

   865     TKeyResponse response = EKeyWasNotConsumed;

   866 

   867     TInt documentLength = -1;

   868     if (iInputCapabilities.FepAwareTextEditor())

   869         {

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

   871         }

   872 

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

   874         {

   875         if (!( aCode == EKeyRightArrow ||

   876              aCode == EKeyLeftArrow ||

   877              aCode == EKeyUpArrow ||

   878              aCode == EKeyDownArrow ))

   879             {

   880             iConcatenationTimer->Cancel();

   881             }

   882         }

   883 

   884 #ifdef RD_INTELLIGENT_TEXT_INPUT    

   885     

   886     if(iKeyBackSpaceHit && aCode != EKeyBackspace)

   887     	iKeyBackSpaceHit = 0;

   888     

   889     if (aCode != EPtiKeyStar && iNumericResourceTimer)

   890         {

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

   892         // iNumericResourceTimer is active

   893         if(NumericResourceMultiTapTimerTimeoutL()&&

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

   895             return EKeyWasConsumed;

   896         }

   897 #endif

   898 

   899 

   900 

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

   902     if ( BidiCursorRequired() )

   903         {

   904         response = AttemptCursorFlipAtAmbiguousPointL( aCode );

   905         if ( response == EKeyWasConsumed )

   906             {

   907             return response;

   908             }

   909         }

   910 

   911     if ( aCode != EPtiKeyHash 

   912 #ifdef RD_INTELLIGENT_TEXT_INPUT

   913 #ifdef __HALF_QWERTY_KEYPAD

   914 #ifdef __SHIFT_KEY_LOOP		

   915     		&& ( aCode != EPtiKeyQwertyLeftShift 

   916     		|| EPtiKeyboardHalfQwerty != KeyboardLayout() )

   917 #endif //__SHIFT_KEY_LOOP

   918 #endif //__HALF_QWERTY_KEYPAD

   919 #endif //RD_INTELLIGENT_TEXT_INPUT   		

   920     		)

   921     

   922         {

   923         

   924         SetLastPressedHashKeyStatus(EFalse);

   925         

   926         if(iHashKeyMan)

   927             {

   928             iHashKeyMan->CancelHashKeyTimer();

   929             if (aCode != EKeyOK)

   930                 {

   931                 iHashKeyMan->ClearSelectionModeHashKeyLoop();

   932                 }

   933             }

   934         }

   935     // Always commit the text before handling arrow keys

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

   937     	{

   938     	if ( aCode == EKeyRightArrow ||

   939              aCode == EKeyLeftArrow ||

   940              aCode == EKeyUpArrow ||

   941              aCode == EKeyDownArrow )

   942     		{

   943     		CommitInlineEditL();

   944        		iPtiEngine->ClearCurrentWord();

   945     		}

   946         }

   947     TBool isPassNext = IsFlagSet(EFlagPassNextKey);

   948    

   949     switch (aCode)

   950         {

   951         case EKeyEscape:

   952 

   953 #ifdef RD_SCALABLE_UI_V2     

   954         if( iFepFullyConstructed && iFepPluginManager)

   955             {

   956             iFepPluginManager->ResetMenuState(EFalse);            

   957             }

   958 #endif         

   959             if (TryCloseUiL())

   960                 {

   961                 response = EKeyWasConsumed;

   962                 // phrase creation

   963                 PhraseCreation(EFalse);

   964                 // phrase creation

   965                 PinyinPhraseCreation(EFalse);

   966                 }

   967             break;

   968 #ifdef RD_INTELLIGENT_TEXT_INPUT

   969 #ifdef __HALF_QWERTY_KEYPAD

   970 #ifdef __SHIFT_KEY_LOOP

   971         case EPtiKeyQwertyLeftShift:

   972         if( EPtiKeyboardHalfQwerty == KeyboardLayout() )

   973         	{

   974 			response = HandleHashKeyL(aLength);

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

   976 			}

   977             break;			

   978 #endif //__SHIFT_KEY_LOOP       	

   979 #endif //__HALF_QWERTY_KEYPAD	

   980 #endif //RD_INTELLIGENT_TEXT_INPUT

   981         case EPtiKeyHash:

   982             if(InputMode() == EHangul)

   983             	{

   984 				if (aLength == EShortKeyPress)

   985 					{

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

   987 					response = EKeyWasConsumed;

   988 					}

   989 				else

   990 					{

   991                	 	//PhraseCreation(EFalse);

   992             		response = HandleHashKeyL(aLength);

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

   994                                         		SetLastPressedHashKeyStatus(ETrue);

   995 					}

   996 				}

   997      	     else if (InputMode()!= EZhuyin)

   998                 {

   999                 if (IsPinyinPhraseCreation() )

  1000                     {

  1001                     ClearCcpuFlag( ECcpuStateHashDown );

  1002                     response = EKeyWasConsumed;

  1003                     }

  1004                 else

  1005                     {

  1006                     response = HandleHashKeyL(aLength);

  1007                     (aLength == ELongKeyPress)

  1008                         ? SetLastPressedHashKeyStatus(EFalse)

  1009                             : SetLastPressedHashKeyStatus(ETrue);

  1010                     }

  1011                 }

  1012             else

  1013                 {

  1014                 PhraseCreation(EFalse);

  1015                 response = HandleHashKeyL(aLength);

  1016                 (aLength == ELongKeyPress)

  1017                     ? SetLastPressedHashKeyStatus(EFalse)

  1018                         : SetLastPressedHashKeyStatus(ETrue);

  1019                 }

  1020             break;

  1021         case EKeyCBA1:

  1022             if(Japanese())

  1023                 {

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

  1025                     {

  1026                     response = EKeyWasConsumed;

  1027                     }

  1028                 break;

  1029                 }

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

  1031             if ( IsEntryPhrase() )

  1032                 {

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

  1034                     {

  1035                     response = EKeyWasConsumed;

  1036                     break;

  1037                     }

  1038                 }

  1039 

  1040             if (!WesternPredictive())

  1041                 {

  1042                 if (TryCloseUiL())

  1043                     {

  1044                     response = EKeyWasConsumed;

  1045                     }

  1046                 }            

  1047             break;

  1048         case EKeyCBA2:

  1049             if(Japanese())

  1050                 {

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

  1052                     {

  1053                     response = EKeyWasConsumed;

  1054                     }

  1055                 break;

  1056                 }

  1057             if (!WesternPredictive())

  1058                 {

  1059                 if (TryCloseUiL())

  1060                     {

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

  1062                     PhraseCreation( EFalse );

  1063                     response = EKeyWasConsumed;

  1064                     }

  1065                 }

  1066      		 else

  1067                 {

  1068                 if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

  1069                     {

  1070                     InternalFepUI()->ExpireMultitapTimer();

  1071                     }

  1072                 }

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

  1074             EntryPhrase( EFalse );

  1075             break;

  1076         case EPtiKeyStar:

  1077             if (IsFlagSet(EFlagPassNextKey))

  1078                 {

  1079                 ClearFlag(EFlagPassNextKey);

  1080                 }

  1081             else if ( !IsFepAwareTextEditor() )

  1082                 {

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

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

  1085                 response = EKeyWasNotConsumed;

  1086                 }

  1087             else if (IsFlagSet(EFlagShiftKeyDepressed))

  1088                 {

  1089                 response = EKeyWasConsumed;

  1090                 }

  1091             else 

  1092                 {

  1093 #ifdef RD_SCALABLE_UI_V2                

  1094                 iStarKeyPressed = ETrue;

  1095 #endif // RD_SCALABLE_UI_V2                    

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

  1097                     {

  1098                     response = EKeyWasConsumed;

  1099                     }

  1100 #ifdef RD_SCALABLE_UI_V2                

  1101                 iStarKeyPressed = EFalse;

  1102 #endif // RD_SCALABLE_UI_V2                     

  1103                 }

  1104             break;

  1105         case EKeyRightArrow:

  1106             if (TryHandleArrowRightEventL(documentLength))

  1107                 {

  1108                 response = EKeyWasConsumed;

  1109                 break;

  1110                 }

  1111             // fall through

  1112         case EKeyLeftArrow:

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

  1114                 {

  1115                 response = EKeyWasConsumed;

  1116                 break;

  1117                 }

  1118                 

  1119             if (IsCcpuFlagSet(ECcpuStateCopy | ECcpuStateCut))    

  1120                 {

  1121                 response = EKeyWasNotConsumed;

  1122                 break;

  1123                 }            

  1124             else if (IsCcpuFlagSet(ECcpuStateStartCopy | ECcpuStateStartCut))    

  1125                 {

  1126                 TryHandleCommonArrowAndBackspaceFunctionalityL(aCode, response);                

  1127                 break;

  1128                 }               

  1129 

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

  1131                 {

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

  1133                     {

  1134                     response = EKeyWasConsumed;