diff -r ebd48d2de13c -r ecbabf52600f fep/aknfep/src/AknFepUiInputStateEntryQwertyWesternPredictive.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fep/aknfep/src/AknFepUiInputStateEntryQwertyWesternPredictive.cpp Wed Sep 01 12:23:33 2010 +0100 @@ -0,0 +1,682 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0"" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Provides the TAknFepInputStateEntryQwertyWesternPredictive methods. +* +*/ + + + + + + + + + + + + +#include "AknFepUiInputStateEntryQwertyWesternPredictive.h" +#include "AknFepUIManagerStateInterface.h" //MAknFepUIManagerStateInterface +#include "AknFepManagerUIInterface.h" //MAknFepManagerUIInterface +#include "AknFepUiManagerWestern.h" +#include "AknFepManager.h" +#include "AknFepPanic.h" +#include "AknFepCaseManager.h" +#include "AknFepPluginManager.h" + +#include //CPtiEngine +#include //keys +#include //MPtiEngineCompositionDataInterface +#include //FeatureManager +#include +#include + + +static const TInt KKeyMappingsLength = 63; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +TAknFepInputStateEntryQwertyWesternPredictive:: +TAknFepInputStateEntryQwertyWesternPredictive(MAknFepUIManagerStateInterface* aOwner) + :TAknFepInputStateBase(aOwner) + { + //this class insists on the existence of a case manager + __ASSERT_DEBUG(iOwner->CaseMan(), AknFepPanic(EAknFepPanicNoCaseManager)); + + iState = EEntry; + iMatchState = EWordMatchNone; + CPtiEngine* ptiengine = iOwner->PtiEngine(); + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + + TPtiTextCase caseMode = ptiengine->Case(); + + ptiengine->SetInputMode(EPtiEngineQwertyPredictive ); + ptiengine->SetCase(caseMode); + TBool isUnlimitedEditor = EFalse; + ptiengine->SetMaxLengthForAutoCompletedCandidates( + fepMan->EditorFreeSpaceForAutoWordCompletion(isUnlimitedEditor )); + +#ifdef RD_INTELLIGENT_TEXT_INPUT + if(fepMan->IsAutoCompleteOn()) + { + TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandEnableAutoCompletion )); + } + else + { + TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandDisableAutoCompletion )); + } + TPtiErrorCorrectionLevel correctionLevel = + (TPtiErrorCorrectionLevel)fepMan->AdvancedPredictiveTypingCorrectionLevel(); + TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandSetCorrectionLevel, + &correctionLevel )); + + TPtiKeyboardType keyboard = fepMan->KeyboardLayout(); + ptiengine->SetKeyboardType(keyboard); + + TBool isNumberCandidateShown = fepMan->IsAdvancedPredictiveNumberCandidateShown(); + TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandSetNumberCandidateStatus, + &isNumberCandidateShown )); + + TBool primaryCandidateState = fepMan->AdvancedPredictivePrimaryCandidate(); + TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandSetProactiveCorrection, + &primaryCandidateState )); +#endif //RD_INTELLIGENT_TEXT_INPUT + } + + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +TBool TAknFepInputStateEntryQwertyWesternPredictive::HandleKeyL(TInt aKey, TKeyPressLength aLength) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CPtiEngine* ptiengine = iOwner->PtiEngine(); + CAknFepFnKeyManager::TFnKeyState fnKeyState = fepMan->FnKeyState(); + if(fnKeyState != CAknFepFnKeyManager::EFnKeyNone) + { + ptiengine->SetCase(EPtiCaseFnLower); + } + + // Handle the Chr cycling + if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) ) + { + if ( iData && (iData != aKey) ) + { + // Chr key is still pressed down but character key was changed from previous one + // to new one. The previous character is committed and PtiEngine starts + // prosessing new key. + ptiengine->CancelTimerActivity(); + + if ( !fepMan->EditorHasFreeSpace() ) + { + return EFalse; + } + } + fepMan->SetFlag( CAknFepManager::EFlagInsideMultitapInlineEditingTransaction ); + } + + TBool response = EFalse; + + + // Handle dead keys with space or backspace. These keys are not mapped in PtiEngine, so they cannot + // be handled there. + if ( ptiengine->HandleCommandL(EPtiCommandDeadKeyWaiting) == 1 ) + { + if ( aKey == EStdKeyBackspace ) + { + // Pending dead key is removed with backspace. No other characters are removed. + ptiengine->HandleCommandL(EPtiCommandGetAndClearDeadKeyRootChar); + response = ETrue; + } + else if ( aKey == EStdKeySpace ) + { + // Dead key followed by space enters the dead key root character + TText deadRoot = ptiengine->HandleCommandL(EPtiCommandGetAndClearDeadKeyRootChar); + ptiengine->HandleCommandL( EPtiCommandAppendCharacter, &deadRoot ); + + TPtrC newText = ptiengine->CurrentWord(); + fepMan->UpdateInlineEditL( newText, newText.Length() ); + iOwner->CaseMan()->UpdateCase(ENullNaviEvent); + + response = ETrue; + } + } + + if (!response) // key not yet handled + { + switch (aKey) + { + case EStdKeySpace: //fall through + case EStdKeyEnter: + case EStdKeyTab: + case EStdKeyLeftArrow: + case EStdKeyRightArrow: + case EStdKeyUpArrow: + case EStdKeyDownArrow: + response = HandleWordBreakingKeysL(aKey); + break; + + // Long press of shift key start copy event. + // Its should handle by framework. + case EStdKeyF21: + case EKeyF21: + // Soft key handle by framework + // Selection key handle by AknFepManeger. + case EStdKeyDevice0: // iCode:EKeyCBA1 + case EStdKeyDevice1: // iCode:EKeyCBA2 + case EStdKeyDevice3: // iCode:EKeyOK + case EKeyCBA1: + case EKeyCBA2: + case EKeyOK: + response = EFalse; + break; + + case EKeyUpArrow: + if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) ) + { +#ifdef RD_INTELLIGENT_TEXT_INPUT + //fepMan->HideExactWordPopUp(); + // Select the exact match with the up arrow and lock it. + // Another alternative could be to call function DoPreviousMatchL() from here + TBool primaryCandidateState = fepMan->AdvancedPredictivePrimaryCandidate(); + TInt wordIndexToSelect = 0; + if (EFalse == primaryCandidateState) + { + ptiengine->HandleCommandL( EPtiCommandUserActionGetIndexOfSecondaryCandidate, + &wordIndexToSelect ); + } + + if (fepMan->IsExactWordPopUpShown()) + { + fepMan->HideExactWordPopUp(); + ptiengine->HandleCommandL( + EPtiCommandUserActionSetCurrentIndexOfCandidates, + &wordIndexToSelect ); + ptiengine->HandleCommandL( EPtiCommandLockCurrentCandidate ); + TPtrC selectedWord = ptiengine->CurrentWord(); + fepMan->UpdateInlineEditL( selectedWord, selectedWord.Length() ); + response = ETrue; + break; + } + else + { + fepMan->LaunchCandidatePopupListL( wordIndexToSelect ); + response = ETrue; + break; + } + +#endif // RD_INTELLIGENT_TEXT_INPUT + } + // fall through + case EKeyDownArrow: + case EKeyLeftArrow: + case EKeyRightArrow: + case EKeyBackspace: + response = HandleNaviKeysL(aKey, aLength); + break; + + + default: + HandleShiftState(aKey); + response = HandleQwertyKeysL(aKey); +#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ +#ifdef RD_INTELLIGENT_TEXT_INPUT + if ( aLength == ELongKeyPress ) + { + // Expire multitap timer after long press. + ptiengine->CancelTimerActivity(); + } +#endif // RD_INTELLIGENT_TEXT_INPUT +#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ + break; + } + } + + iData = aKey; // store the pressed key for future reference + return response; + } + + +////////////////////////////////////////////////////////////////////////////////// +// +void TAknFepInputStateEntryQwertyWesternPredictive::HandleShiftState( TInt aKey ) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CPtiEngine* ptiengine = iOwner->PtiEngine(); + CAknFepCaseManager* caseMan = iOwner->CaseMan(); + CAknFepFnKeyManager::TFnKeyState fnKeyState = fepMan->FnKeyState(); + TPtiTextCase shiftedCase; + if(fnKeyState != CAknFepFnKeyManager::EFnKeyNone) + { + shiftedCase = EPtiCaseFnLower; + } + else + { + shiftedCase= EPtiCaseLower; + } + + TBool portraitFSQ = FeatureManager::FeatureSupported( + KFeatureIdFfVirtualFullscrPortraitQwertyInput ) + && fepMan->PluginUIManager() + && fepMan->PluginUIManager()->PluginInputMode() == EPluginInputModePortraitFSQ; + + // For addition of ITI features. + // When FSQ is opened wiht ITI features enabled, + // after pressing keys, don't need to re-set current text case by editor's text or FN key state. + // Because FSQ's case doesn't obey editor's case and there is no fn key on FSQ. + if ( fepMan->PluginUIManager() + && ( fepMan->PluginUIManager()->PluginInputMode() == EPluginInputModeFSQ + || portraitFSQ ) + && fepMan->WesternPredictive() ) + { + return; + } + + // Find out if the key is alphabetic + TBuf keyMappings; + ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseUpper ); + TBool isAlpha = ( keyMappings.Length() && TChar(keyMappings[0]).IsAlpha() ); + + if (isAlpha && (fnKeyState == CAknFepFnKeyManager::EFnKeyNone)) + { + switch ( caseMan->CurrentCase() ) + { + case EAknEditorTextCase: + { + // Alphabetic characters are always capitalized in "Abc" mode + // unless the shift is pressed + // Thai language should not go to automatic capitalization in text case + // mode and predictive input. This is because it would lead to the character + // mapped to upper case being displayed instead of the intended character. + // So below is what is essentially a XNOR condition - + // 1) no-shiftkey and language with case => upper case + // 2) no-shiftkey and language without case => lower case + // 3) shiftkey and language with case => lower case + // 4) shiftkey and language without case => upper case + TInt inputLang = ptiengine->CurrentLanguage()->LanguageCode(); + if ( ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) || + fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress) ) + == ( inputLang == ELangThai || + inputLang == ELangArabic || + inputLang == ELangFarsi || + inputLang == ELangHebrew || + inputLang == ELangUrdu || + inputLang == ELangHindi ) ) + { + shiftedCase = EPtiCaseUpper; + } + } + break; + + case EAknEditorLowerCase: + { + // Pressing shift enters uppercae letters in the "abc" mode + if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) || + fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress) ) + { + shiftedCase = EPtiCaseUpper; + } + } + break; + + case EAknEditorUpperCase: + { + // In the "ABC" mode (capslock mode) the letters are uppercased + // unless the shift is pressed + if ( !(fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode)|| + fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress)) ) + { + shiftedCase = EPtiCaseUpper; + } + } + break; + + default: + break; + } + + + } + else + { + // non-alphabetic keys are shifted if and only if shift is pressed, no matter what is the input state + if ( (fnKeyState == CAknFepFnKeyManager::EFnKeyNone) && + ( fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress) || + fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) ) ) + { + shiftedCase = EPtiCaseUpper; + } + else if( (fnKeyState == CAknFepFnKeyManager::EFnKeyNext) && + (caseMan->CurrentCase() == EAknEditorTextCase || + caseMan->CurrentCase() == EAknEditorUpperCase || + fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress) || + fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode))) + { + shiftedCase = EPtiCaseFnUpper; + } + else if (( fepMan->IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress) || + fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode)) && + (fnKeyState != CAknFepFnKeyManager::EFnKeyNone)) + { + shiftedCase = EPtiCaseFnUpper; + } + } + + + // Handle the Chr key state + if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) ) + { + // Chr key is pressed down. Chr mode is used. + if (shiftedCase == EPtiCaseLower) + { + shiftedCase = EPtiCaseChrLower; + } + else if (shiftedCase == EPtiCaseUpper) + { + shiftedCase = EPtiCaseChrUpper; + } + } + + ptiengine->SetCase(shiftedCase); + + fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringShiftKeyPress); + } + + +////////////////////////////////////////////////////////////////////////////////// +// + +TBool TAknFepInputStateEntryQwertyWesternPredictive::HandleWordBreakingKeysL(TInt aKey) + { + TBool retVal = EFalse; // in most cases we let also the upper levels handle these key events + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CPtiEngine* ptiengine = iOwner->PtiEngine(); + CAknFepFnKeyManager::TFnKeyState fnKeyState = fepMan->FnKeyState(); + + + // Up and down arrows break the inline word input only when shift or chr is held down + if ( !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) && + !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) && + ( aKey==EStdKeyUpArrow || aKey==EStdKeyDownArrow ) ) + { + return retVal; + } + + + if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) ) + { + TBool rightToLeftLang = fepMan->IsRightToLeftLanguage(); + TInt tailLength = 0; + ptiengine->HandleCommandL( EPtiCommandGetAutoCompletionTailLength, &tailLength ); + switch (aKey) + { + case EStdKeyLeftArrow: + case EStdKeyRightArrow: + // In case the inline editing is ongoing and there is a word completion + // currently shown, the first backwards tap will remove the suggested + // completion. + if(tailLength > 0) + { + if ((rightToLeftLang && aKey == EStdKeyLeftArrow) + || (! rightToLeftLang && aKey == EStdKeyRightArrow )) + { + ptiengine->HandleCommandL( EPtiCommandLockCurrentCandidate); + TPtrC selectedWord = ptiengine->CurrentWord(); + fepMan->UpdateInlineEditL( selectedWord, selectedWord.Length() ); //selection.iAnchorPosition + // To fix the Suggested word is not committed when Arrow right key is pressed. + ptiengine->CommitCurrentWord(); + fepMan->TryCloseUiL(); + // Asyncronous case update after the editor has handled the key + fepMan->SimulateKeyEventL(EKeyF19); + retVal = ETrue; + } + else if((rightToLeftLang && aKey == EStdKeyRightArrow) + || (! rightToLeftLang && aKey == EStdKeyLeftArrow )) + { + fepMan->RemoveSuggestedAdvanceCompletionL(); + retVal = ETrue; + } + } + else + { + ptiengine->CommitCurrentWord(); + retVal = EFalse; + } + break; + case EStdKeyUpArrow: + case EStdKeyDownArrow: + case EStdKeyEnter: + case EStdKeySpace: + case EStdKeyTab: + { + //retVal = ETrue; + TBool wasInlineEditing = EFalse; + wasInlineEditing = + fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction); + + if(aKey == EStdKeySpace && tailLength > 0) + { + fepMan->RemoveSuggestedAdvanceCompletionL(); + } + + ptiengine->CommitCurrentWord(); + fepMan->CommitInlineEditL(); + /* Temporary Fix */ + //EFlagInsideInlineEditingTransaction flag check is not required + //but just to make sure. + if (aKey == EStdKeySpace && fnKeyState == CAknFepFnKeyManager::EFnKeyDown) + fepMan->LaunchSelectModeMenuL(); + else if(aKey == EStdKeySpace && wasInlineEditing) + { + _LIT(KSpace," "); + fepMan->StartInlineEditL(); + fepMan->UpdateInlineEditL(KSpace,0); + fepMan->CommitInlineEditL(); + retVal = ETrue; + } + /* Temporary Fix */ + fepMan->TryCloseUiL(); + // Asyncronous case update after the editor has handled the key + fepMan->SimulateKeyEventL(EKeyF19); + } + break; + default: + __ASSERT_DEBUG( EFalse, AknFepPanic(EAknFepPanicNotSupportKey) ); + } + + } + else + { + iOwner->ChangeState( EInitial ); + } + + return retVal; + } + + +///////////////////////////////////////////////////////////////////////////////// +// +TBool TAknFepInputStateEntryQwertyWesternPredictive::HandleQwertyKeysL(TInt aKey) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CPtiEngine* ptiengine = iOwner->PtiEngine(); + + CAknFepCaseManager* caseMan = iOwner->CaseMan(); + CAknFepFnKeyManager::TFnKeyState fnKeyState = fepMan->FnKeyState(); + + // Key is consumed if the PtiEngine maps it to some character + TBuf keyMappings; + + if(fnKeyState != CAknFepFnKeyManager::EFnKeyNone) + { + + // Try to know is there any mapping for function upper + // char. For user point of view this changes has been made. + if( ptiengine->Case() == EPtiCaseFnUpper ) + { + ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseFnUpper); + } + else + { + ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseFnLower); + } + } + else + { + ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseLower); + } + //ITI : Pti Engine can be asked to give the proper data for the keys under Fn Key. + TBool keyIsMapped = ( keyMappings.Length() > 0 ); + + // The dead key handling inside the PtiDefaultCore assumes that no other key mapping queries + // have been made between handling the dead key and the next one (these queries change the + // internal state of the key mapping object). For this reason, we must return the key mappings + // to their previous state. This is quite dirty hack, but so is the dead key handling code which + // forces us to do this. + if(fnKeyState != CAknFepFnKeyManager::EFnKeyNone) + { + ptiengine->MappingDataForKey( (TPtiKey)iData, keyMappings, EPtiCaseFnLower); + } + else + { + ptiengine->MappingDataForKey( (TPtiKey)iData, keyMappings, EPtiCaseLower); + } + + // For user point of view this changes has been made. + // If key does not map to function upper char, then try to insert + // functionized char. + if( (EPtiCaseFnUpper == ptiengine->Case()) && !keyIsMapped ) + { + ptiengine->SetCase((TPtiTextCase)EPtiCaseFnLower); + ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseFnLower); + keyIsMapped = ( keyMappings.Length() > 0 ); + } + + if ( keyIsMapped ) + { + if ( !(fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction)) ) + { // 'new' inline edit + ptiengine->ClearCurrentWord(); + if (caseMan->CurrentCase() == EAknEditorTextCase) + { + ptiengine->MarkAutoCapitalized(); + } + + fepMan->StartInlineEditL(); + } + + TPtrC newText = ptiengine->AppendKeyPress((TPtiKey)aKey); + fepMan->UpdateInlineEditL(newText, newText.Length()); + + // Normally we update the case after key press. However, if Chr key is held down, the case update + // must not happen until when the Chr is released or the timer expires (in both of these cases + // the function KeyTimerExpired() will get callled). + if ( !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) ) + { + iOwner->CaseMan()->UpdateCase(ENullNaviEvent); + } + else + { + fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringChrKeyPress); + } + + return ETrue; + } + // MT error fixing : If any key does not map any functionized char, + // its should not display any char fn mode, other behaviour as usual. + // If the Fn key stae indicate that fn key pres & we are looking for functionnized + // char, if its not availble it will do nothing. So we have to block the event + // go to framework. + if( aKey!=EStdKeyBackspace && fnKeyState != CAknFepFnKeyManager::EFnKeyNone) + return ETrue; + + // Framework will handle the key event. + return EFalse; + } + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +// +TBool TAknFepInputStateEntryQwertyWesternPredictive::HandleNaviKeysL(TInt aKey, TKeyPressLength /*aLength*/) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CPtiEngine* ptiengine = iOwner->PtiEngine(); + + if (!(fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))) + { + TBuf textToUncommit; + TBool comsumeKey; + if (!(fepMan->TryGetTextToUncommitL(textToUncommit, aKey, comsumeKey))) + { + // If T9 word length > 32, the navi key is consumed without action. + // Maybe should navigate inside word. + return comsumeKey; + } + ptiengine->ClearCurrentWord(); + ptiengine->SetCurrentWord(textToUncommit); // this set the input sequence of PtiEngine + fepMan->StartInlineEditL(fepMan->UncommittedText(), textToUncommit, + textToUncommit.Length(), EFalse); + } + + if (aKey == EKeyBackspace) + { + TPtrC newText = ptiengine->DeleteKeyPress(); + TPtrC selectedWord = ptiengine->CurrentWord(); + fepMan->UpdateInlineEditL(selectedWord, selectedWord.Length()); + + fepMan->ClearFlag(CAknFepManager::EFlagRemoveMatchesMenuItem); + if (ptiengine->NumberOfCandidates() <= 1) + { + fepMan->SetFlag(CAknFepManager::EFlagRemoveMatchesMenuItem); + } + + iOwner->CaseMan()->UpdateCase(EBackspaceEvent); + fepMan->CloseUiIfWordDeletedL(); + } + + return ETrue; + } + + +///////////////////////////////////////////////////////////////////////////// +// +void TAknFepInputStateEntryQwertyWesternPredictive::LastWordInSelectionList() + { + + } + + +////////////////////////////////////////////////////////////////////////////// +// +void TAknFepInputStateEntryQwertyWesternPredictive::FirstWordInSelectionList() + { + } + + +///////////////////////////////////////////////////////////////// +// +void TAknFepInputStateEntryQwertyWesternPredictive::KeyTimerExpired() + { + if (iData) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CAknFepCaseManager* caseMan = iOwner->CaseMan(); + caseMan->UpdateCase(ENullNaviEvent); + fepMan->ClearFlag( CAknFepManager::EFlagInsideMultitapInlineEditingTransaction ); + iData = 0; + } + } + + +// End of file