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 const TInt KSelectItemSize(10);

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

   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 = 25;

   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     EAknCmdEditModeKorean,

   210     EAknCmdEditModeEnglish

   211     };   

   212      

   213 #endif // RD_SCALABLE_UI_V2 

   214 

   215 

   216 // Number modes used by Arabic or Hindi.

   217 enum TNonLatinNumberModes

   218     { 

   219     ENbrModeLatin,

   220     ENbrModeArabic = 1,

   221     ENbrModeIndic = 1

   222     };

   223 

   224 // Number mode type

   225 enum TNonLatinNumberModeType

   226     {

   227     ENbrModeTypeArabic,

   228     ENbrModeTypeIndic,

   229     ENbrModeTypeEasternArabic //for Urdu & Farsi languages

   230     };

   231     

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

   233 const TInt KSyncPasswdTimeout = 1000000;

   234 

   235 #ifdef RD_SCALABLE_UI_V2

   236 TUid AppUidFromWndGroupId(TInt aWndGrpId);

   237 extern TUid GetCurAppUid();

   238 extern TBool IsGlobalNotesApp(TUid& aUid);

   239 TInt GetForegroundTaskAppWgId();

   240 #endif

   241 #ifdef RD_INTELLIGENT_TEXT_INPUT

   242 const TInt KWordToFocusInCandidateList = 1;

   243 #endif

   244 

   245 LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

   246 

   247 //

   248 // Class TTextDirectionalInfo

   249 //

   250 /**

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

   252 */

   253 CAknFepManager::TTextDirectionalInfo::TTextDirectionalInfo() : 

   254 iDirectionalStatus(EUnknown), iBlockEnvironment(EUndefined)

   255     {}

   256 

   257 void CAknFepManager::TTextDirectionalInfo::SetDirectionFromChunk( 

   258                const CTmTextLayout::TTmChunkDescription& aChunk )

   259     {

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

   261         iDirectionalStatus = aChunk.iRightToLeft ? ERightToLeft : ELeftToRight;

   262     }

   263 

   264 

   265 void TFepLanguageTranslation::ReadFromResource(TResourceReader& aReader)

   266     {

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

   268     iLanguageId = aReader.ReadInt16();

   269     iCommandId = aReader.ReadInt16();

   270     }

   271 

   272 

   273 CAknFepManager::CAknFepManager(CCoeEnv& aConeEnvironment)

   274     :CCoeFep(aConeEnvironment),

   275     iAsyncResouceChanged(EActivePriorityDefault),

   276     iPreviousEditingState(EStateNone),

   277     iInputCapabilities(TCoeInputCapabilities::ENone),

   278     iModeBefore(ELatin),

   279     #ifdef RD_INTELLIGENT_TEXT_INPUT

   280     iKeyPressedDuringShift(EFalse),

   281 #endif

   282     iCharWidth(EHalfWidthChar),

   283     iAsyncOwnSimulateKey(EActivePriorityDefault),

   284     iLongThai0Key(EFalse),

   285     iEditCharsPtr(0,0),

   286     iComposChrFlag(0),

   287     iIsUserdbdlgActive(0),

   288     iLongClearAfterCloseUI(EFalse),

   289     // phrase creation

   290     iPhraseCreation(0),

   291     iPinyinPhraseCreation(0),

   292     iEntryPhrase(0)

   293     

   294 

   295     {

   296     }

   297 

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

   299     {

   300     BaseConstructL(aFepParameters);

   301     iUiInterface = CAknFepUIInterface::NewL();

   302     iIndicator = iUiInterface->NewIndicatorL();

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

   304 

   305     // Set up resources

   306     TFileName resourceName(KAknFepResourceFileName);

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

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

   309     iResId = coeEnv->AddResourceFileL(resourceName);

   310 

   311     // Save Japanese Feature support to a member variable

   312     iFeatureSupportedJapanese = FeatureManager::FeatureSupported(KFeatureIdJapanese);

   313 

   314     iUiLanguage = User::Language();

   315     

   316     // Shared Data

   317     iSharedDataInterface = CAknFepSharedDataInterface::NewL(this);

   318 

   319     TInt previUiLanguage = iSharedDataInterface->PluginUILanguage();

   320 

   321     if (iUiLanguage != previUiLanguage)

   322         {

   323         

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

   325         iSharedDataInterface->SetPluginUILanguage(iUiLanguage);

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

   327         }

   328 

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

   330         {

   331         switch (iUiLanguage)

   332             {

   333             case ELangPrcChinese:

   334                 iSharedDataInterface->SetInputMode(EPinyin);

   335                 break;

   336             case ELangTaiwanChinese:

   337                 iSharedDataInterface->SetInputMode(EZhuyin);

   338                 break;

   339             case ELangHongKongChinese:

   340                 iSharedDataInterface->SetInputMode(EStroke);

   341                 iSharedDataInterface->SetCangJieMode(ECangJieNormal);

   342                 break;

   343             case ELangJapanese:

   344                 iSharedDataInterface->SetInputMode(EHiraganaKanji);

   345                 break;

   346             case ELangKorean:

   347                 iSharedDataInterface->SetInputMode(EHangul);

   348                 break;

   349             case ELangHindi:

   350                 iSharedDataInterface->SetInputMode(EHindi);

   351                 break;

   352             default:

   353                 iSharedDataInterface->SetInputMode(ELatin);

   354                 break;

   355             }

   356         }

   357 

   358     iUiInterface->SetFepMenuObserver(this);

   359    

   360     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   361 

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

   363     // which is needed for updating locale repository.

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

   365     TSecurityInfo info;

   366     info.Set(RProcess());

   367 

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

   369     

   370     if (!inputLanguage && hasCapability)

   371         {

   372         // set correct input language

   373         inputLanguage = SubstituteSublanguageId(iUiLanguage);

   374         

   375         // If Ptiengine is not initialize, initialize it

   376         if (!iPtiEngine)

   377             {

   378             iPtiEngine = CPtiEngine::NewL(ETrue);    

   379             }         

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

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

   382             {

   383             inputLanguage = ELangEnglish;   

   384             }

   385         

   386         // Set the current input language

   387         iSharedDataInterface->SetInputTextLanguage(inputLanguage);

   388         

   389         // update numeric input

   390         if ( iUiLanguage == ELangArabic ) 

   391             {

   392             SetDefaultNumberMode( ENbrModeArabic, 

   393                                   ENbrModeTypeArabic );

   394             }            

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

   396                   ( iUiLanguage == ELangFarsi  ) )

   397             {

   398             SetDefaultNumberMode( ENbrModeArabic, 

   399                                   ENbrModeTypeEasternArabic );

   400             }

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

   402             {

   403             SetDefaultNumberMode( ENbrModeLatin, 

   404                                   ENbrModeTypeIndic );

   405             }

   406         else

   407             {           

   408             SetDefaultNumberMode( ENbrModeLatin, ENbrModeTypeArabic );

   409             }

   410         }

   411         

   412     iSctEditChars = HBufC::NewL( 10 );

   413     

   414 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

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

   417 				iExactWordPopupContent = iUiInterface->CreateWordPopupContentL();

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

   419 #endif //RD_INTELLIGENT_TEXT_INPUT

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

   421     // for all applications at application startup.

   422     // ConstructFullyL();

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

   424 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   426 #endif

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

   428     if(result == KErrNone)

   429         {

   430         iKeyCatcher->ActivateL();

   431         }

   432     // the follow 3 objects for phrase creation

   433     iZhuyinKeyHandler = CZhuyinKeyHandler::NewL();

   434     iZhuyinAnalyserDb = CZhuyinAnalyserDbFeed::NewL(EPinyinAnalyserTypeZhuyin);

   435     iZhuyinAnalyser = CAknFepZhuyinAnalyser::NewL(iZhuyinAnalyserDb);

   436     iAknFepThaiSCTSelector = CAknFepThaiSCTSelector::NewL();

   437     iHybridAplphaChangedToAlphanumeric = EFalse;

   438     iLastFocusedEditor = NULL;

   439     iFepAwareDialogParentEditor = NULL;

   440     }

   441 

   442 void CAknFepManager::ConstructFullyL()

   443     {

   444     if (!iPtiEngine)

   445         {

   446         iPtiEngine = CPtiEngine::NewL(ETrue);    

   447         } 

   448     

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

   450         {

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

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

   453         TInt inputLang = SubstituteSublanguageId(iUiLanguage);

   454         

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

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

   457             {

   458             inputLang = ELangEnglish;   

   459             }

   460         iSharedDataInterface->SetInputTextLanguage(inputLang);      

   461         }      

   462 #ifdef RD_INTELLIGENT_TEXT_INPUT

   463 #ifdef FF_DUAL_LANGUAGE_SUPPORT

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

   465         {

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

   467         iSharedDataInterface->SetInputTextLanguageSecondary(0);

   468         }

   469 #endif //FF_DUAL_LANGUAGE_SUPPORT

   470 #endif

   471         

   472     if(NULL == iKeyCatcher)

   473         {

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

   475         iKeyCatcher->ActivateL();

   476         }

   477     

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

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

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

   481 

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

   483     TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

   484 #ifdef RD_INTELLIGENT_TEXT_INPUT

   485 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   486     TInt inputLanguageSecondary = iSharedDataInterface->InputTextLanguageSecondary();

   487 #endif //FF_DUAL_LANGUAGE_SUPPORT

   488 #endif

   489     SetWesternPredictive(iSharedDataInterface->PredictiveTextOn());

   490 #ifndef RD_INTELLIGENT_TEXT_INPUT

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

   492 #endif	//RD_INTELLIGENT_TEXT_INPUT

   493 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   495     iTypingCorrectionLevel = iSharedDataInterface->PredictiveTextTypingCorrectionLevel();

   496     iIsNumberCandidateShown = iSharedDataInterface->PredictiveTextNumberCandidateShown();

   497     TInt primaryCandidateValue = iSharedDataInterface->PredictiveTextPrimaryCandidate();

   498     if( primaryCandidateValue == 0)

   499 		iPrimaryCandidate = ETrue;

   500 	else if(primaryCandidateValue == 1)

   501 		iPrimaryCandidate = EFalse; 

   502 #endif // RD_INTELLIGENT_TEXT_INPUT

   503     iJapanesePredictive = iSharedDataInterface->PredictiveTextJapaneseOn();

   504     iQwertyInputMode = iSharedDataInterface->QwertyInputMode();

   505     iMultiTapTimer = iSharedDataInterface->MultiTapTimer();

   506     iJapaneseQwertyFlags = iSharedDataInterface->JapaneseQwertyFlags();

   507 #ifdef RD_INTELLIGENT_TEXT_INPUT

   508     if(!iFnKeyManager)

   509         {

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

   511         }    

   512 #endif

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

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

   515     iPtiEngine->ActivateLanguageL(inputLanguage);

   516 #ifdef RD_INTELLIGENT_TEXT_INPUT

   517 #ifdef FF_DUAL_LANGUAGE_SUPPORT

   518     iPtiEngine->SetSecondaryInputL(inputLanguageSecondary);

   519 #endif //FF_DUAL_LANGUAGE_SUPPORT

   520 #endif

   521     iLangMan->SetInputLanguageL(inputLanguage);

   522     SetInputLanguageCapabilities(inputLanguage);

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

   524 

   525     iLastKeyPressedWasHashKey = EFalse;

   526     iDeviceSupportsRtlLanguage = DeviceSupportsRTLLanguageL();

   527 

   528     TResourceReader reader;

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

   530     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_SPACE_SYMBOL);

   531     iSpaceCharacterCode = reader.ReadUint16();

   532     coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_FULLWIDTHSPACE_SYMBOL);

   533     iFullWidthSpaceCharacterCode = reader.ReadUint16();

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

   535 

   536     //initialise states

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

   538     SyncStates(EAknFepStateNull);

   539     ResetFlags();

   540     ResetExtendedFlags();

   541 

   542     ReadHashKeyLoopL();

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

   544     SetHashKeyStyle();

   545     iInlineTextDecorator = new (ELeave) CAknFepInlineTextDecorator;

   546     if (IsFeatureSupportedJapanese())

   547         {

   548         CAknJapaneseReading::CreateL(iPtiEngine);

   549         }

   550     // setting call back

   551     TCallBack callback(DoSimulateKey, this);

   552     iAsyncOwnSimulateKey.Set(callback);

   553     

   554     TCallBack resourcechangedcallback(HandleResourceChangedCallback,this);

   555     iAsyncResouceChanged.Set(resourcechangedcallback);

   556 #ifdef RD_SCALABLE_UI_V2

   557     iFepPluginManager = CAknFepPluginManager::NewL

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

   559     iNotifyPlugin = ETrue;

   560 #endif //RD_SCALABLE_UI_V2

   561 

   562     iFepFullyConstructed = ETrue;

   563 #ifdef RD_INTELLIGENT_TEXT_INPUT

   564     iIsFnKeyMapped = IsFnKeyMappedL();

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

   566 #endif

   567     }

   568 

   569 CAknFepManager::~CAknFepManager()

   570     {

   571 #ifdef RD_PF_SEC_APPARC

   572     delete iNullService;

   573 #else

   574     //Embedding - removing created document

   575     if ( iEmbedded )

   576         {

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

   578         iEmbedded = NULL;

   579         }

   580 #endif

   581     if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   582         {

   583         SetFlag(CAknFepManager::EFlagSupressAutoUpdate);

   584         TRAPD(err, CommitInlineEditL())

   585         if (err)

   586             {

   587             CleanUpFep();

   588             }

   589         }

   590         

   591     if ( EditorState() )

   592         {

   593         EditorState()->SetObserver(NULL);    

   594         }        

   595     if (iLastFocusedEditor)

   596         {

   597         iLastFocusedEditor->SetObserver(NULL);

   598         iLastFocusedEditor = NULL;

   599         } 

   600     if (iFepAwareDialogParentEditor)

   601         {

   602         iFepAwareDialogParentEditor->SetObserver(NULL);

   603         iFepAwareDialogParentEditor = NULL;

   604         } 

   605     

   606     delete iSharedDataInterface;

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

   608     if (indicator == iIndicator)

   609         {

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

   611         }

   612 

   613         

   614     delete iIndicator;

   615     iIndicator = NULL;

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

   617 

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

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

   620     CommonDestroyFep();

   621 

   622 	if (iUiInterface)

   623 	    iUiInterface->SetFepMenuObserver(NULL);

   624 

   625     delete iPtiEngine;

   626     delete iSctEditChars;

   627 

   628 #ifdef RD_SCALABLE_UI_V2

   629     if ( FepAwareTextEditor() )

   630         {

   631     		UnregisterObserver();

   632         }

   633     delete iFepPluginManager;

   634     delete iStylusCcpuMenu;        

   635 

   636     delete iSpellInitText;        

   637 #endif // RD_SCALABLE_UI_V2

   638     delete iUiInterface;

   639 #ifdef RD_INTELLIGENT_TEXT_INPUT

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

   641     delete iExactWordPopupContent;

   642     iExactWordPopupContent = 0;

   643     delete iCandidatePopup;

   644     iCandidatePopup = 0;

   645     delete iResourceString;

   646     iResourceString = 0;

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

   648 #endif //RD_INTELLIGENT_TEXT_INPUT

   649     // the follow objects for phrase creation

   650       delete iZhuyinKeyHandler;

   651       delete iZhuyinAnalyser;

   652     delete iAknFepThaiSCTSelector;

   653     }

   654 

   655 void CAknFepManager::CommonDestroyFep()

   656     {

   657     iFepFullyConstructed = EFalse;

   658 

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

   660     iAsyncOwnSimulateKey.Cancel();

   661     iAsyncResouceChanged.Cancel();

   662     delete iShiftKeypressMonitor;

   663     iShiftKeypressMonitor = NULL;

   664     delete iConcatenationTimer;

   665     iConcatenationTimer = NULL;

   666     delete iChrKeypressMonitor;

   667     iChrKeypressMonitor = NULL;

   668     delete iLangMan;

   669     iLangMan = NULL;

   670     iCurrentFepUI = NULL;

   671     delete iKeyCatcher;

   672     iKeyCatcher = NULL;

   673 

   674     delete iPostEventCheck;

   675     iPostEventCheck = NULL;

   676     delete iHashKeyMan;

   677     iHashKeyMan = NULL;

   678     delete iCaseMan;

   679     iCaseMan = NULL;

   680     delete iInlineTextDecorator;

   681     iInlineTextDecorator = NULL;

   682     iHashKeyLoop.Close();

   683 #ifdef RD_INTELLIGENT_TEXT_INPUT

   684     if(iFnKeyManager)

   685         {

   686         delete iFnKeyManager;

   687         iFnKeyManager = NULL;

   688         }

   689     if( iNumericResourceTimer )        

   690         {

   691         delete iNumericResourceTimer;

   692         iNumericResourceTimer = NULL;    

   693         }

   694 #endif

   695     }

   696 

   697 #ifdef RD_INTELLIGENT_TEXT_INPUT

   698 void CAknFepManager::SetKeyboardLayout(TPtiKeyboardType aType)

   699     {

   700     	

   701     if(iQwertyInputMode && iFnKeyManager 

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

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

   704 		{

   705         	iMode = ENumber;

   706 		}

   707 	

   708 	if(iFnKeyManager)        

   709 		{

   710 		iFnKeyManager->ClearFnKeyState();

   711 		}

   712     	

   713     if(iPtiEngine)

   714         {

   715         iPtiEngine->SetKeyboardType(aType);

   716         }    

   717     iKeyboardType = aType;        

   718     }

   719 

   720 TPtiKeyboardType CAknFepManager::KeyboardLayout() const

   721     {

   722     return iKeyboardType;

   723     }

   724 #endif

   725 TBool CAknFepManager::TryCloseUiL()

   726     {

   727 #ifdef RD_HINDI_PHONETIC_INPUT        

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

   729          IsFlagSet(CAknFepManager::EFlagNoMatches))

   730         {

   731         ClearFlag(CAknFepManager::EFlagNoMatches);

   732     	if (PreviousChar() == KQuestionMark)

   733     		RemovePreviousCharacterL();

   734     	}

   735 #endif    

   736     if (iFepManState == EAknFepStateUIActive)

   737         {

   738         // In Japanese input,

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

   740         if (!IsFeatureSupportedJapanese() || WesternPredictive())

   741             {

   742             if (IsFlagSet(EFlagInsideInlineEditingTransaction))

   743                 {

   744                 TryRemoveNoMatchesIndicatorL();

   745                 UpdateCbaL(NULL);

   746                 }

   747                 

   748              	

   749 

   750 //#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   751 #ifdef RD_INTELLIGENT_TEXT_INPUT

   752             if ( iFepPluginManager && 

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

   754             	{

   755             	RemoveSuggestedAdvanceCompletionL();

   756             	}            

   757 #endif // RD_INTELLIGENT_TEXT_INPUT              

   758 //#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

   759                 

   760 #ifdef RD_SCALABLE_UI_V2 

   761                

   762             if (iFepPluginManager->BeforeSpell())

   763                 {

   764                 iFepPluginManager->SetBeforeSpell(EFalse);

   765                 }

   766             else

   767 #endif  

   768           

   769                 {

   770                 CommitInlineEditL();    

   771                 }

   772             }

   773         if (IsCcpuFlagSet(ECcpuStataCommitPredictiveWord))            

   774             {

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

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

   777             iPtiEngine->CommitCurrentWord();

   778             ClearCcpuFlag(ECcpuStataCommitPredictiveWord);

   779             }            

   780         InternalFepUI()->CloseUI();

   781         SyncStates(EAknFepStateInitial);

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

   783             {

   784             SetCursorType(EActive);

   785             if ( EditorState() )

   786             	{

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

   788             	}            

   789             }

   790 

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

   792         if (IsFeatureSupportedJapanese() 

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

   794             {

   795             return EFalse;

   796             }

   797 

   798         return ETrue;

   799         }

   800     else

   801         {

   802     	if (IsKoreanInputLanguage())

   803         	{

   804         	if (IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

   805         		{

   806         	   	CommitInlineEditL();

   807         		PtiEngine()->ClearCurrentWord();

   808         		}

   809         	}

   810     	

   811         //in initial state characters should either:

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

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

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

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

   816         if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

   817             {

   818             InternalFepUI()->ExpireMultitapTimer();

   819             }

   820         return EFalse;

   821         }

   822     }

   823 

   824 void CAknFepManager::SendUIActivatedNotification()

   825     {

   826     SyncStates(EAknFepStateUIActive);

   827     }

   828 

   829 void CAknFepManager::SendUIDeActivatedNotification()

   830     {

   831     SyncStates(EAknFepStateInitial);

   832     }

   833 

   834 void CAknFepManager::PlaySound(TAvkonSystemSID aSound) const

   835     {

   836     if (SoundSystem())

   837         {

   838         SoundSystem()->PlaySound(aSound);

   839         }

   840     }

   841     

   842 void CAknFepManager::SetLongClearAfterCloseUI(TBool aLongClear)

   843     {

   844     iLongClearAfterCloseUI = aLongClear;

   845     }

   846 

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

   848     {

   849     TKeyResponse response = EKeyWasNotConsumed;

   850 

   851     TInt documentLength = -1;

   852     if (iInputCapabilities.FepAwareTextEditor())

   853         {

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

   855         }

   856 

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

   858         {

   859         if (!( aCode == EKeyRightArrow ||

   860              aCode == EKeyLeftArrow ||

   861              aCode == EKeyUpArrow ||

   862              aCode == EKeyDownArrow ))

   863             {

   864             iConcatenationTimer->Cancel();

   865             }

   866         }

   867 

   868 #ifdef RD_INTELLIGENT_TEXT_INPUT    

   869     

   870     if(iKeyBackSpaceHit && aCode != EKeyBackspace)

   871     	iKeyBackSpaceHit = 0;

   872     

   873     if (aCode != EPtiKeyStar && iNumericResourceTimer)

   874         {

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

   876         // iNumericResourceTimer is active

   877         if(NumericResourceMultiTapTimerTimeoutL()&&

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

   879             return EKeyWasConsumed;

   880         }

   881 #endif

   882 

   883 

   884 

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

   886     if ( BidiCursorRequired() )

   887         {

   888         response = AttemptCursorFlipAtAmbiguousPointL( aCode );

   889         if ( response == EKeyWasConsumed )

   890             {

   891             return response;

   892             }

   893         }

   894 

   895     if ( aCode != EPtiKeyHash 

   896 #ifdef RD_INTELLIGENT_TEXT_INPUT

   897 #ifdef __HALF_QWERTY_KEYPAD

   898 #ifdef __SHIFT_KEY_LOOP		

   899     		&& ( aCode != EPtiKeyQwertyLeftShift 

   900     		|| EPtiKeyboardHalfQwerty != KeyboardLayout() )

   901 #endif //__SHIFT_KEY_LOOP

   902 #endif //__HALF_QWERTY_KEYPAD

   903 #endif //RD_INTELLIGENT_TEXT_INPUT   		

   904     		)

   905     

   906         {

   907         

   908         SetLastPressedHashKeyStatus(EFalse);

   909         

   910         if(iHashKeyMan)

   911             {

   912             iHashKeyMan->CancelHashKeyTimer();

   913             if (aCode != EKeyOK)

   914                 {

   915                 iHashKeyMan->ClearSelectionModeHashKeyLoop();

   916                 }

   917             }

   918         }

   919     // Always commit the text before handling arrow keys

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

   921     	{

   922     	if ( aCode == EKeyRightArrow ||

   923              aCode == EKeyLeftArrow ||

   924              aCode == EKeyUpArrow ||

   925              aCode == EKeyDownArrow )

   926     		{

   927     		CommitInlineEditL();

   928        		iPtiEngine->ClearCurrentWord();

   929     		}

   930         }

   931     TBool isPassNext = IsFlagSet(EFlagPassNextKey);

   932    

   933     switch (aCode)

   934         {

   935         case EKeyEscape:

   936 

   937 #ifdef RD_SCALABLE_UI_V2     

   938         if( iFepFullyConstructed && iFepPluginManager)

   939             {

   940             iFepPluginManager->ResetMenuState(EFalse);            

   941             }

   942 #endif         

   943             if (TryCloseUiL())

   944                 {

   945                 response = EKeyWasConsumed;

   946                 // phrase creation

   947                 PhraseCreation(EFalse);

   948                 // phrase creation

   949                 PinyinPhraseCreation(EFalse);

   950                 }

   951             break;

   952 #ifdef RD_INTELLIGENT_TEXT_INPUT

   953 #ifdef __HALF_QWERTY_KEYPAD

   954 #ifdef __SHIFT_KEY_LOOP

   955         case EPtiKeyQwertyLeftShift:

   956         if( EPtiKeyboardHalfQwerty == KeyboardLayout() )

   957         	{

   958 			response = HandleHashKeyL(aLength);

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

   960 			}

   961             break;			

   962 #endif //__SHIFT_KEY_LOOP       	

   963 #endif //__HALF_QWERTY_KEYPAD	

   964 #endif //RD_INTELLIGENT_TEXT_INPUT

   965         case EPtiKeyHash:

   966             if(InputMode() == EHangul)

   967             	{

   968 				if (aLength == EShortKeyPress)

   969 					{

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

   971 					response = EKeyWasConsumed;

   972 					}

   973 				else

   974 					{

   975                	 	//PhraseCreation(EFalse);

   976             		response = HandleHashKeyL(aLength);

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

   978                                         		SetLastPressedHashKeyStatus(ETrue);

   979 					}

   980 				}

   981      	     else if (InputMode()!= EZhuyin)

   982                 {

   983                 if (IsPinyinPhraseCreation() )

   984                     {

   985                     ClearCcpuFlag( ECcpuStateHashDown );

   986                     response = EKeyWasConsumed;

   987                     }

   988                 else

   989                     {

   990                     response = HandleHashKeyL(aLength);

   991                     (aLength == ELongKeyPress)

   992                         ? SetLastPressedHashKeyStatus(EFalse)

   993                             : SetLastPressedHashKeyStatus(ETrue);

   994                     }

   995                 }

   996             else

   997                 {

   998                 PhraseCreation(EFalse);

   999                 response = HandleHashKeyL(aLength);

  1000                 (aLength == ELongKeyPress)

  1001                     ? SetLastPressedHashKeyStatus(EFalse)

  1002                         : SetLastPressedHashKeyStatus(ETrue);

  1003                 }

  1004             break;

  1005         case EKeyCBA1:

  1006             if(Japanese())

  1007                 {

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

  1009                     {

  1010                     response = EKeyWasConsumed;

  1011                     }

  1012                 break;

  1013                 }

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

  1015             if ( IsEntryPhrase() )

  1016                 {

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

  1018                     {

  1019                     response = EKeyWasConsumed;

  1020                     break;

  1021                     }

  1022                 }

  1023 

  1024             if (!WesternPredictive())

  1025                 {

  1026                 if (TryCloseUiL())

  1027                     {

  1028                     response = EKeyWasConsumed;

  1029                     }

  1030                 }            

  1031             break;

  1032         case EKeyCBA2:

  1033             if(Japanese())

  1034                 {

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

  1036                     {

  1037                     response = EKeyWasConsumed;

  1038                     }

  1039                 break;

  1040                 }

  1041             if (!WesternPredictive())

  1042                 {

  1043                 if (TryCloseUiL())

  1044                     {

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

  1046                     PhraseCreation( EFalse );

  1047                     response = EKeyWasConsumed;

  1048                     }

  1049                 }

  1050      		 else

  1051                 {

  1052                 if ( IsFlagSet( EFlagInsideInlineEditingTransaction ) )

  1053                     {

  1054                     InternalFepUI()->ExpireMultitapTimer();

  1055                     }

  1056                 }

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

  1058             EntryPhrase( EFalse );

  1059             break;

  1060         case EPtiKeyStar:

  1061             if (IsFlagSet(EFlagPassNextKey))

  1062                 {

  1063                 ClearFlag(EFlagPassNextKey);

  1064                 }

  1065             else if ( !IsFepAwareTextEditor() )

  1066                 {

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

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

  1069                 response = EKeyWasNotConsumed;

  1070                 }

  1071             else if (IsFlagSet(EFlagShiftKeyDepressed))

  1072                 {

  1073                 response = EKeyWasConsumed;

  1074                 }

  1075             else 

  1076                 {

  1077 #ifdef RD_SCALABLE_UI_V2                

  1078                 iStarKeyPressed = ETrue;

  1079 #endif // RD_SCALABLE_UI_V2                    

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

  1081                     {

  1082                     response = EKeyWasConsumed;

  1083                     }

  1084 #ifdef RD_SCALABLE_UI_V2                

  1085                 iStarKeyPressed = EFalse;

  1086 #endif // RD_SCALABLE_UI_V2                     

  1087                 }

  1088             break;

  1089         case EKeyRightArrow:

  1090             if (TryHandleArrowRightEventL(documentLength))

  1091                 {

  1092                 response = EKeyWasConsumed;

  1093                 break;

  1094                 }

  1095             // fall through

  1096         case EKeyLeftArrow:

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

  1098                 {

  1099                 response = EKeyWasConsumed;

  1100                 break;

  1101                 }

  1102                 

  1103             if (IsCcpuFlagSet(ECcpuStateCopy | ECcpuStateCut))    

  1104                 {

  1105                 response = EKeyWasNotConsumed;

  1106                 break;

  1107                 }            

  1108             else if (IsCcpuFlagSet(ECcpuStateStartCopy | ECcpuStateStartCut))    

  1109                 {

  1110                 TryHandleCommonArrowAndBackspaceFunctionalityL(aCode, response);                

  1111                 break;

  1112                 }               

  1113 

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

  1115                 {

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

  1117                     {

  1118                     response = EKeyWasConsumed;

  1119                     }

  1120                 }

  1121             else

  1122                 {

  1123                 if (WesternPredictive())

  1124                     {

  1125                     response = HandleWesternPredictiveArrowKeyL(aCode, aLength);

  1126                     }

  1127                 else

  1128                     {

  1129                     if (iFepManState == EAknFepStateUIActive)

  1130                         {

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

  1132                         response = EKeyWasConsumed;

  1133                         }

  1134                     else