diff -r 000000000000 -r eb1f2e154e89 fep/aknfep/src/AknFepUiManagerBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fep/aknfep/src/AknFepUiManagerBase.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1020 @@ +/* +* Copyright (c) 2002-2004 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 CAknFepUIManagerBase methods. +* +*/ + + + + + + + + + + + + +// INCLUDE FILES +#include +#include // RDebug stuff... + +#include "AknFepGlobalEnums.h" +#include "AknFepUiManagerBase.h" + +// Western input +#include "AknFepUiInputStateInitialLatinMultitap.h" +#include "AknFepUiInputStateInitialNumber.h" +#include "AknFepUiInputStateInitialWesternPredictive.h" +#include "AknFepUiInputStateEntryWesternPredictive.h" + +#include "AknFepCaseManager.h" +#include "AknFepPanic.h" + +#include +#include // CAknIndicatorContainer::TIndicatorContext +#include +#include + +// CONSTANTS +const TInt KNumberOfKeymapResources = 8; +const TInt KNumericKeymapResourceIds[KNumberOfKeymapResources] = + { + R_AKNFEP_NUMBER_MODE_KEYMAP_STANDARD, + R_AKNFEP_NUMBER_MODE_KEYMAP_PLAIN, + R_AKNFEP_NUMBER_MODE_KEYMAP_CALCULATOR, + R_AKNFEP_NUMBER_MODE_KEYMAP_CONVERTER, + R_AKNFEP_NUMBER_MODE_KEYMAP_TO_FIELD, + R_AKNFEP_NUMBER_MODE_KEYMAP_FIXED_DIALLING, + R_AKNFEP_NUMBER_MODE_KEYMAP_SAT, + R_AKNFEP_NUMBER_MODE_KEYMAP_SAT_HIDDEN + }; + +#define EAknEditorNativeKeysNumberModeKeymap EAknEditorReservedInternalUseKeymap + +/** +* CAknFepUIManagerBase class. +* +*/ + +//============================ MEMBER FUNCTIONS ============================== + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::NewL +// +// +// --------------------------------------------------------------------------- +// +CAknFepUIManagerBase* CAknFepUIManagerBase::NewL(MAknFepManagerUIInterface* aFepMan, + CAknFepCaseManager* aCaseMan, TLanguage aLanguage) + { + CAknFepUIManagerBase* self = new(ELeave)CAknFepUIManagerBase(aFepMan, aCaseMan); + CleanupStack::PushL(self); + self->ConstructL(aLanguage); + CleanupStack::Pop(); + return self; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::~CAknFepUIManagerBase +// +// +// --------------------------------------------------------------------------- +// +CAknFepUIManagerBase::~CAknFepUIManagerBase() + { + CloseUI(); + delete iNumericKeymapBuffer; + } + +/** + * MAknFepManagerInterface class. + * + */ +//============================ MEMBER FUNCTIONS ============================== + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetMode +// +// +// --------------------------------------------------------------------------- +// +#ifdef RD_INTELLIGENT_TEXT_INPUT +void CAknFepUIManagerBase::SetMode(TInt aMode, + TBool aPredictive, + TBool aQwertyInputMode, + TInt aKeyboardType) +#else +void CAknFepUIManagerBase::SetMode(TInt aMode, TBool aPredictive, TBool aQwertyInputMode) +#endif + { + iMode=aMode; + iPredictive = aPredictive; +#ifdef RD_INTELLIGENT_TEXT_INPUT + iQwertyInputMode = aQwertyInputMode; // predictive QWERTY changes (e.g. XT9) +#endif //RD_INTELLIGENT_TEXT_INPUT + if (aQwertyInputMode +#ifdef RD_INTELLIGENT_TEXT_INPUT + && !aPredictive // predictive QWERTY changes (e.g. XT9): added second condition +#endif //RD_INTELLIGENT_TEXT_INPUT + ) + { +#ifdef RD_INTELLIGENT_TEXT_INPUT + if (aKeyboardType == EPtiKeyboardHalfQwerty) + { + ChangeState(EHalfQwerty); + } + else + { +#endif + ChangeState(EQwerty); +#ifdef RD_INTELLIGENT_TEXT_INPUT + } +#endif + } + else + { + ChangeState(EInitial); + } + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetCase +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetCase(TCase aCase) + { +#ifdef RD_INTELLIGENT_TEXT_INPUT + TPtiTextCase newCase = EPtiCaseLower; + + TBool noResetCase = EFalse; + + switch( aCase ) + { + case EUpperCase: + { + newCase = EPtiCaseUpper; + } + break; + case ELowerCase: + { + newCase = EPtiCaseLower; + } + break; + case EFnKeyLowerCase: + { + newCase = EPtiCaseFnLower; + } + break; + + case EFnKeyUpperCase: + { + newCase = EPtiCaseFnUpper; + noResetCase = ETrue; + } + break; + + default: + break; + } + + CAknFepFnKeyManager::TFnKeyState fnKeyState = iFepMan->FnKeyState(); +#ifdef __REVERSE_FN_KEY_SUPPORTED + // For Reverse Fn key mapping + if(!iFepMan->IsReverseFnkeyInput()) + { +#endif //__REVERSE_FN_KEY_SUPPORTED + switch (fnKeyState) + { + case CAknFepFnKeyManager::EFnKeyLock: + case CAknFepFnKeyManager::EFnKeyForced: + case CAknFepFnKeyManager::EFnKeyDown: + if( !noResetCase ) + newCase = EPtiCaseFnLower; + break; + case CAknFepFnKeyManager::EFnKeyNone: + case CAknFepFnKeyManager::EFnKeyPressed: + case CAknFepFnKeyManager::EFnKeyNext: + case CAknFepFnKeyManager::EFnKeyPressedAgain: + default: + break; + } +#ifdef __REVERSE_FN_KEY_SUPPORTED + } +#endif //__REVERSE_FN_KEY_SUPPORTED + PtiEngine()->SetCase( newCase ); +#else + PtiEngine()->SetCase((aCase == EUpperCase)? EPtiCaseUpper : EPtiCaseLower); +#endif + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetNumberModeKeyMappingL +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetNumberModeKeyMappingL( + TAknEditorNumericKeymap aAknEditorNumericKeymap) + { + __ASSERT_DEBUG( + (aAknEditorNumericKeymap >= 0 && aAknEditorNumericKeymap < KNumberOfKeymapResources) || + (aAknEditorNumericKeymap == EAknEditorAlphanumericNumberModeKeymap) || + (aAknEditorNumericKeymap == EAknEditorNativeKeysNumberModeKeymap), + AknFepPanic(EAknFepPanicIllegalNumberModeKeymapping)); + +#ifdef RD_INTELLIGENT_TEXT_INPUT + if (aAknEditorNumericKeymap == EAknEditorAlphanumericNumberModeKeymap && iNumericKeymapBuffer) + { + delete iNumericKeymapBuffer; + iNumericKeymapBuffer = NULL; + return; + } +#endif + + // Fep does not handle keys when EAknEditorNativeKeysNumberModeKeymap is used. + if (aAknEditorNumericKeymap != EAknEditorNativeKeysNumberModeKeymap && + aAknEditorNumericKeymap != EAknEditorAlphanumericNumberModeKeymap) + { + TInt keymapResourceId = KNumericKeymapResourceIds[aAknEditorNumericKeymap]; + if (iNumericKeymapResourceId != keymapResourceId || !iNumericKeymapBuffer) + { + delete iNumericKeymapBuffer; + iNumericKeymapBuffer = NULL; + iNumericKeymapBuffer = CCoeEnv::Static()->AllocReadResourceL( keymapResourceId ); + iNumericKeymapResourceId = keymapResourceId; + } + } + } + +const TDesC& CAknFepUIManagerBase::NumberModeKeyMapping() const + { + if (iNumericKeymapBuffer) + { + return *iNumericKeymapBuffer; + } + return KNullDesC; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::HandleKeyL +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::HandleKeyL(TInt aKey, TKeyPressLength aLength, TEventCode /*aEventCode*/) + { + if (!iStatePtr) + { + return EFalse; + } + + TUIState currentState = iStatePtr->State(); + if (aLength == EShortKeyPress) + { + iInitialFepUIState = currentState; + } +#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ +#ifdef RD_INTELLIGENT_TEXT_INPUT + // Calculate and store the number of characters now and the delta with + // the last key press to be used when long press substitutes the initial + // character. + + // This change is done for fixing the error :- Long keypress + // inputs the alphabet as well along with number/special character + // when candidate list is open. + + TInt curInputSeqLen = 0; + TInt curEditorTextLen = 0; + TInt curWordLen = 0; + if (aLength == EShortKeyPress) + { + curInputSeqLen = PtiEngine()->CurrentInputSequence().Length(); + curWordLen = PtiEngine()->CurrentWord().Length(); + curEditorTextLen = FepMan()->DocumentLength(); + iCaseBeforeLongKey = CaseMan()->CurrentCase(); + } + + if ( aLength == ELongKeyPress ) + { + if ( HandleLongKeyL( aKey ) ) + { + return ETrue; + } + } + + TInt retVal = ETrue; + TBool handledKey = iStatePtr->HandleKeyL(aKey, aLength); + if(!handledKey) + { + if(currentState != iStatePtr->State()) //Check to see if we've changed state. + { + retVal = iStatePtr->HandleKeyL(aKey, aLength); + } + else + { + retVal = EFalse; // we've failed to handle it.. + } + } + + // The delta is calculated after the short key press character is entered. + // The check with EStdKeyF21 is done to fix the bug : + // When prediction is off, keep shift key pressed down. + // Just before the editor enters the selection mode, + // do a long press of a number key. Along with the number + // even the alphabet is entered. + if (aLength == EShortKeyPress && (handledKey || retVal) && (aKey!=EStdKeyF21)) + { + // for the punctuation key, the autocompletion part is accepted, + // because of which the delta has to be calculated + // based on the current word length + if( aKey == EStdKeyFullStop && EPtiKeyboardHalfQwerty == FepMan()->KeyboardLayout()) + { + iInputSeqLenDeltaWithLastKey = PtiEngine()->CurrentWord().Length() - curWordLen; + } + else + { + iInputSeqLenDeltaWithLastKey = PtiEngine()->CurrentInputSequence().Length() - curInputSeqLen; + } + iEditorTextLenDeltaWithLastKey = FepMan()->DocumentLength() - curEditorTextLen; + // This change is done to fix the bug : Select the text + // using shift key. Do a long press of a key. Along + // with the number even the alphabet is entered. + if(iEditorTextLenDeltaWithLastKey <= 0) + { + iEditorTextLenDeltaWithLastKey = iStatePtr->GetShortKeyPressTxtLength(); + } + } + + else if ( aLength == EShortKeyPress && + EPtiKeyboardHalfQwerty == FepMan()->KeyboardLayout() && + EFalse == retVal && PtiEngine()->IsValidKey((TPtiKey)aKey)) + { + // reset the two deltas + iInputSeqLenDeltaWithLastKey = 0; + iEditorTextLenDeltaWithLastKey = 0; + } + + return retVal; +#endif // RD_INTELLIGENT_TEXT_INPUT +#else + + if(!iStatePtr->HandleKeyL(aKey, aLength)) + { + if(currentState != iStatePtr->State()) //Check to see if we've changed state. + { + return iStatePtr->HandleKeyL(aKey, aLength); + } + return EFalse; // we've failed to handle it.. + } + return ETrue; //we're ok. +#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ + + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::HandleCommandL +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::HandleCommandL(TInt aCommandId) + { + iStatePtr->HandleCommandL(aCommandId); + } + +void CAknFepUIManagerBase::HandleCommandL(TInt aCommandId, TInt /*aParam*/) + { + iStatePtr->HandleCommandL(aCommandId); + } +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::CloseUI +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::CloseUI() + { + ChangeState(EInitial); + } + + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::ExpireMultitapTimer +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::ExpireMultitapTimer() + { + PtiEngine()->CancelTimerActivity(); + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsValidNumericLongKeyPress +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsValidNumericLongKeyPress(TInt aKey) const + { + TBool response = EFalse; + + switch(aKey) + { + case EPtiKey0: + case EPtiKey1: + case EPtiKey2: + case EPtiKey3: + case EPtiKey4: + case EPtiKey5: + case EPtiKey6: + case EPtiKey7: + case EPtiKey8: + case EPtiKey9: + if (iInitialFepUIState == EInitial || + iInitialFepUIState == EPredictiveCandidate) + { + response = ETrue; + } + break; + default: + break; + } + return response; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::AddTextToUserDictionaryL +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::AddTextToUserDictionaryL(const TDesC& /*aText*/) + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::GetFormatOfFepInlineText +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::GetFormatOfFepInlineText(TCharFormat& /*aFormat*/, TInt& /*aNumberOfCharactersWithSameFormat*/, TInt /*aPositionOfCharacter*/) const + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SupportLanguage +// +// +// --------------------------------------------------------------------------- +// +TInt CAknFepUIManagerBase::SupportLanguage(TInt /*aMode*/) const + { + return iLanguage; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetInputLanguageL +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetInputLanguageL(TLanguage aLanguage) + { + iLanguage = aLanguage; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsValidShiftKeyPress +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsValidShiftKeyPress() const + { + return ETrue; + } + +#ifdef RD_INTELLIGENT_TEXT_INPUT +TBool CAknFepUIManagerBase::IsValidFnKeyPress() const + { + return ETrue; + } + + +TBool CAknFepUIManagerBase::IsValidLongChrKeyPress() const + { + return ETrue; + } + +#endif +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetEditorContext +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetEditorContext(TInt /*aContext*/) + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::ActivateUI +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::ActivateUI() + { + } + +/** + * MAknFepUIManagerStateInterface class. + * + */ +//============================ MEMBER FUNCTIONS ============================== + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::State +// +// +// --------------------------------------------------------------------------- +// +TUIState CAknFepUIManagerBase::State() const + { + return iStatePtr->State(); + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::ChangeState +// +// +// --------------------------------------------------------------------------- +// +TUIState CAknFepUIManagerBase::ChangeState(TUIState aState) + { +// iFepUiState = TAknFepInputStateBase(this); +#ifdef _DEBUG + RDebug::Print(_L("UI Manager: New State: %d"), iStatePtr->State()); +#endif + return aState; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::FepMan +// +// +// --------------------------------------------------------------------------- +// +MAknFepManagerUIInterface* CAknFepUIManagerBase::FepMan() const + { + return iFepMan; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::PtiEngine +// +// +// --------------------------------------------------------------------------- +// +CPtiEngine* CAknFepUIManagerBase::PtiEngine() const + { + return iPtiEngine; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsValidChineseInputKey +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsValidChineseInputKey(TInt /*aKey*/) const + { + return ETrue; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsValidChineseInputKeyQwerty +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsValidChineseInputKeyQwerty(TInt /*aKey*/) const + { + return ETrue; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::UpdateCangJieState +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::UpdateCangJieState() + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsValidChineseSymbol +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsValidChineseSymbol(TInt /*akey*/) const + { + return ETrue; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsQwertyZhuyinToneMarkKey +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsQwertyZhuyinToneMarkKey(TInt /*aKey*/) const + { + return ETrue; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::GetLanguage +// +// +// --------------------------------------------------------------------------- +// +TLanguage CAknFepUIManagerBase::GetLanguage() const + { + return iLanguage; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::CaseMan +// +// +// --------------------------------------------------------------------------- +// +CAknFepCaseManager* CAknFepUIManagerBase::CaseMan() const + { + return iCaseMan; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::GetLatestDeliberateSelection +// +// +// --------------------------------------------------------------------------- +// +TPtr CAknFepUIManagerBase::GetLatestDeliberateSelection() const + { + return TPtr(NULL, 0, 0); + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::ThaiSCTResourceId +// +// +// --------------------------------------------------------------------------- +// +TInt CAknFepUIManagerBase::ThaiSCTResourceId(TUint /*aPrewChar*/,TInt /*aKey*/) + { + return 0; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::CandidateArray +// +// +// --------------------------------------------------------------------------- +// +CDesCArrayFlat* CAknFepUIManagerBase::CandidateArray() + { + return NULL; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsPredictive +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsPredictive() const + { + return EFalse; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetInlineEditUnderlineVisibility +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetInlineEditUnderlineVisibility(TBool /*aFlag*/) + { + } + +/** + * CAknFepUIManagerBase class. + * + */ +//============================ MEMBER FUNCTIONS ============================== + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::CAknFepUIManagerBase +// +// +// --------------------------------------------------------------------------- +// +CAknFepUIManagerBase::CAknFepUIManagerBase(MAknFepManagerUIInterface* aFepMan, + CAknFepCaseManager* aCaseMan) + :iMode(ENumber), + iFepMan(aFepMan), + iCaseMan(aCaseMan) + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::ConstructL +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::ConstructL(TLanguage aLanguage) + { + iPtiEngine = iFepMan->PtiEngine(); // Get PtiEngine + iLanguage = aLanguage; + iStatePtr = FepUIState(); + SetNumberModeKeyMappingL(EAknEditorStandardNumberModeKeymap); + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::FepUIState +// +// +// --------------------------------------------------------------------------- +// +TAknFepInputStateBase* CAknFepUIManagerBase::FepUIState() + { + return NULL; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::IsQwerty +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::IsQwerty() const + { + return EFalse; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetFepAwareEditorText +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetFepAwareEditorText(const TFepInputContextFieldData& /*aIcfData*/) + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::EditorMaxLength +// +// +// --------------------------------------------------------------------------- +// +TInt CAknFepUIManagerBase::EditorMaxLength() + { + return 0; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SizeChanged +// +// +// --------------------------------------------------------------------------- +// +const TInt KResourceChanged = 1; +void CAknFepUIManagerBase::ResourceChanged(TInt /*aType*/) + { + if ( !iStatePtr ) + { + return; + } + + TRAP_IGNORE(iStatePtr->HandleCommandL(KResourceChanged)); + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetNextFepUI +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetNextFepUI(MAknFepManagerInterface* /*aNextUi*/) + { + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::SetStarKeyFlag +// +// +// --------------------------------------------------------------------------- +// +void CAknFepUIManagerBase::SetStarKeyFlag( TBool aSet ) + { + if ( iStatePtr ) + { + iStatePtr->SetStarKeyFlag( aSet ); + } + } +#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ +#ifdef RD_INTELLIGENT_TEXT_INPUT +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::HandleLongKeyL +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::HandleLongKeyL( TInt aKey ) + { +#ifdef _DEBUG + RDebug::Print( _L("HandleLongKeyL(%c)"), aKey ); +#endif + + TBool consume = EFalse; + + if ( iQwertyInputMode && // Long press implementation for non-QWERTY modes is elsewhere + iFepMan->LongPressNumberEntryOnQwerty() && // Is long press number entry supported + iFepMan->FnKeyState() == CAknFepFnKeyManager::EFnKeyNone && // Long press is handled differently only in non-Fn modes + iFepMan->KeyMapsDifferentCharacterWithFn( (TPtiKey)aKey ) ) // Does the given key have a different character in Fn mode + { + TBool charRemoved = RollbackPreviousCharL(); + + // Continue only if there's space left in the editor field after the rollback. + // In case of secret editor, the removal of the initial character is asynchronous. + // In that case the editor may still seem to be filled up although we have already + // queued the rollback event. + if ( iFepMan->EditorHasFreeSpace() || charRemoved ) + { + // Long key press load, if editor in textcase mode reload the + // text case mode, because shrot key press reset textcase mode. + CaseMan()->SetCurrentCase(iCaseBeforeLongKey); + + iFepMan->SetFnKeyState( CAknFepFnKeyManager::EFnKeyNext ); + + // Figure out the used case (upper/lower) + TPtiTextCase ptiCase = EPtiCaseFnLower; + + if ( CaseMan()->CurrentCase() == EAknEditorTextCase || + CaseMan()->CurrentCase() == EAknEditorUpperCase ) + { + ptiCase = EPtiCaseFnUpper; + } + + if ( iFepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) && + CaseMan()->IsAbleChangeCase() ) + { + // QWERTY shift mode => swap the case + if ( ptiCase == EPtiCaseFnLower ) + ptiCase = EPtiCaseFnUpper; + else + ptiCase = EPtiCaseFnLower; + } + + // In case we are in uppercase mode but there's no characters mapped to that mode, + // use the lower case instead. + if ( ptiCase == EPtiCaseFnUpper ) + { + TBuf<1> upperFnMapping; + iPtiEngine->MappingDataForKey( (TPtiKey)aKey, upperFnMapping, EPtiCaseFnUpper ); + if ( !upperFnMapping.Length() ) + { + ptiCase = EPtiCaseFnLower; + } + } + + iPtiEngine->SetCase( ptiCase ); + } + else + { + consume = ETrue; + } + } + return consume; + } + +// --------------------------------------------------------------------------- +// CAknFepUIManagerBase::RollbackPreviousCharL +// +// +// --------------------------------------------------------------------------- +// +TBool CAknFepUIManagerBase::RollbackPreviousCharL() + { + TBool characterRemoved = ETrue; + + if( iFepMan->KeyboardLayout() == EPtiKeyboardHalfQwerty ) + { + if (iFepMan->IsFlagSet(CAknFepManager::EFlagNoMatches)) + { + iFepMan->TryRemoveNoMatchesIndicatorL(); + iFepMan->UpdateCbaL(NULL); + // make sure that the candidates + // will be updated the next time + iPtiEngine->HandleCommandL(EPtiCommandSetFlagToUpdateCandidates); + // Need to return as DeleteKeyPress should not be passed to ptiengine. + // This is because ptiengine does not maintain the input sequence + // if the key press does not increase the word length. So when no matches + // character is (?) is deleted, no need to pass to ptiengine. This is to done + // to solve the bug :enter characters till the no matches character is shown. Now press + // backspace, last character is not deleted. + return ETrue; + } + } + + // It depends on the editor type and input mode, how the previous character + // can be rolled back. + if ( iPtiEngine->HandleCommandL(EPtiCommandDeadKeyWaiting) > 0 ) + { + // The previous key entered a dead character + iPtiEngine->HandleCommandL(EPtiCommandGetAndClearDeadKeyRootChar); + } + else if ( iInputSeqLenDeltaWithLastKey > 0 ) + { + // The previous key entered chracter(s) to input sequence of PtiEngine + for ( TInt i=0 ; iDeleteKeyPress(); + } + if ( iFepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) ) + { + TPtrC curWord = iPtiEngine->CurrentWord(); + iFepMan->UpdateInlineEditL( curWord, curWord.Length() ); + } + if ( iFepMan->IsSupportsSecretText() ) + { + // Fep communicates with secret text editors using simulated events. + iFepMan->SimulateKeyEventL(EKeyF20); + iFepMan->ClearFlag( CAknFepManager::EFlagInsideMultitapInlineEditingTransaction); + } + + } + else if ( iEditorTextLenDeltaWithLastKey > 0 ) + { + // The previous key entered character(s) directly to the editor + for ( TInt i=0 ; iIsSupportsSecretText() ) + { + // Fep communicates with secret text editors using simulated events. + iFepMan->SimulateKeyEventL(EKeyF20); + iFepMan->ClearFlag(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction); + } + else + { + // In normal editors, the character can be removed directly + iFepMan->RemovePreviousCharacterL(); + } + } + } + else + { + // The previous key press produced no characters => do nothing + characterRemoved = EFalse; + } + + return characterRemoved; + } +#endif // RD_INTELLIGENT_TEXT_INPUT +#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ + +// add for phrase creation +MZhuyinKeyHandler* CAknFepUIManagerBase::ZhuyinKeyHandler() + { + return iFepMan->ZhuyinKeyHandler(); + } +//add for phrase creation +CAknFepZhuyinAnalyser* CAknFepUIManagerBase::ZhuyinAnalyser() + { + return iFepMan->ZhuyinAnalyser(); + } + +// End of file