diff -r 000000000000 -r eb1f2e154e89 fep/aknfep/src/AknFepUiInputStateInitialHalfQwertyWesternPredictive.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fep/aknfep/src/AknFepUiInputStateInitialHalfQwertyWesternPredictive.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,357 @@ +/* +* Copyright (c) 2002 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 TAknFepInputStateInitialHalfQwertyWesternPredictive methods. +* +*/ + + + + + + + + + + + + +#include "AknFepUiInputStateInitialHalfQwertyWesternPredictive.h" +#include "AknFepUIManagerStateInterface.h" //MAknFepUIManagerStateInterface +#include "AknFepManagerUIInterface.h" //MAknFepManagerUIInterface +#include "AknFepManager.h" +#include "AknFepCaseManager.h" //CAknFepCaseManager + +#include +#include + +// TODO: Remove this include +#include +static const TInt KKeyMappingsLength = 32; +TAknFepUiInputStateInitialHalfQwertyWesternPredictive::TAknFepUiInputStateInitialHalfQwertyWesternPredictive(MAknFepUIManagerStateInterface* aOwner) + //:TAknFepInputStateBase(aOwner), + :TAknFepInputStateInitialMultitapBase(aOwner) + { + iData = 0; + CPtiEngine* ptiengine = iOwner->PtiEngine(); + // this is already being done in the base constructor + // should not be done again +// TPtiTextCase caseMode = ptiengine->Case(); +// ptiengine->ClearCurrentWord(); +// ptiengine->SetCase(caseMode); + ptiengine->SetInputMode( EPtiEngineHalfQwerty ); + } + +TBool TAknFepUiInputStateInitialHalfQwertyWesternPredictive::HandleKeyL(TInt aKey, TKeyPressLength aLength) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + + TBool retVal = EFalse; + TBuf mappedCharacters; + if (iData && (iData != aKey) && fepMan->IsFlagSet(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction)) + { + iOwner->PtiEngine()->CancelTimerActivity(); + fepMan->CommitInlineEditL(); + iOwner->PtiEngine()->ClearCurrentWord(); + fepMan->ClearFlag(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction); + iData = 0; + // if the current fn key state is FnNext, then clear it. + if( !fepMan->IsFlagSet( CAknFepManager::EFlagLongShiftKeyPress ) ) + { + if( CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState()) + { + fepMan->SetFnKeyState( CAknFepFnKeyManager::EFnKeyNone ); + } + } + } + HandleShiftState(aKey); + if((fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed))&& (aKey !=EStdKeyBackspace) && (aKey!=EKeyBackspace)) + { + if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) ) + { + fepMan->TryRemoveNoMatchesIndicatorL(); + } + if (fepMan->IsAutoCompleteOn()) + { + TInt tailLength = 0; + iOwner->PtiEngine()->HandleCommandL( EPtiCommandGetAutoCompletionTailLength, &tailLength ); + if(tailLength > 0) + { + // To remove the autocompletion part, the below function is used. + // DeleteKeyPress was used earlier. This is removed to fix the bug : + // enter characters to show autocompletion part. Now press a + // character so that the no matches character is shown. Now press + // backspace key, last character is not deleted. + fepMan->RemoveSuggestedAdvanceCompletionL(); + return ETrue; + } + } + // for long key press do not go to multitap base + if( EShortKeyPress == aLength ) + { + TAknFepInputStateInitialMultitapBase::HandleKeyL(aKey, aLength); + } + else + { + mappedCharacters.Zero(); + iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey + , mappedCharacters, iOwner->PtiEngine()->Case()); + fepMan->NewCharacterL(mappedCharacters); + fepMan->CommitInlineEditL(); + } + // cancel the multitap timer if only one character is mapped to it + mappedCharacters.Zero(); + + iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey, mappedCharacters, iOwner->PtiEngine()->Case()); + + if( mappedCharacters.Length() < 2 ) + { + iOwner->PtiEngine()->CancelTimerActivity(); + } + + iData = aKey; + fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringChrKeyPress); + return ETrue; + } + // for long press of punct key, a stream of characters mapped to + // that case should be shown both in predictive and non-predictive mode + if ( aLength == ELongKeyPress && aKey == EStdKeyFullStop ) + { + // Long press should always input fnlower character + iOwner->PtiEngine()->SetCase( EPtiCaseFnLower); + + mappedCharacters.Zero(); + iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey + , mappedCharacters, iOwner->PtiEngine()->Case()); + fepMan->NewCharacterL(mappedCharacters); + fepMan->CommitInlineEditL(); + return ETrue; + } + switch (aKey) + { + case EStdKeyLeftShift: + case EStdKeyRightShift: + case EStdKeyLeftFunc: + { + // Handle shift key seperately only if fn state is set. + if( CAknFepFnKeyManager::EFnKeyPressed == fepMan->FnKeyState() || + CAknFepFnKeyManager::EFnKeyDown == fepMan->FnKeyState() || + CAknFepFnKeyManager::EFnKeyForced == fepMan->FnKeyState() || + CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState() || + CAknFepFnKeyManager::EFnKeyPressedAgain == fepMan->FnKeyState() || + CAknFepFnKeyManager::EFnKeyLock == fepMan->FnKeyState()) + { + fepMan->PtiEngine()->SetCase( EPtiCaseFnLower ); + TAknFepInputStateInitialMultitapBase::HandleKeyL(aKey, aLength); + // cancel the multitap timer if only one character is mapped to it + mappedCharacters.Zero(); + iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey, mappedCharacters, iOwner->PtiEngine()->Case()); + + if( mappedCharacters.Length() < 2 ) + { + iOwner->PtiEngine()->CancelTimerActivity(); + } + } + } + break; + + case EStdKeyNull: + // Take no action if simulated key ends up here + break; + + case EStdKeySpace: //fall through + { + _LIT(KSpace," "); + if( fepMan->FnKeyState() == CAknFepFnKeyManager::EFnKeyNone) + { + fepMan->StartInlineEditL(); + fepMan->UpdateInlineEditL(KSpace,0); + fepMan->CommitInlineEditL(); + return ETrue; + } + else + { + // Most keys activate the entry state and are handled there + fepMan->TryCloseUiL(); //expires the multitap timer + iOwner->ChangeState(EEntry); + fepMan->SendUIActivatedNotification(); + } + break; + } + case EStdKeyEnter: + case EStdKeyTab: + case EStdKeyBackspace: + case EStdKeyLeftArrow: + case EStdKeyRightArrow: + case EStdKeyUpArrow: + case EStdKeyDownArrow: + { + // Navigation keys do not activate the entry state. Instead they are handled by the editor directly. + + // Asyncronous case update is needed after the editor has handled the key + fepMan->SimulateKeyEventL(EKeyF19); + if (((aKey == EStdKeyBackspace) || (aKey == EKeyBackspace)) && (fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed))) + fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringChrKeyPress); + } + break; + default: + { + // Most keys activate the entry state and are handled there + fepMan->TryCloseUiL(); //expires the multitap timer + iOwner->ChangeState(EEntry); + fepMan->SendUIActivatedNotification(); + } + } + + if ( aKey == EStdKeyEnter) + { + iData = 0; + return 0; + } + if( !iOwner->PtiEngine()->IsValidKey((TPtiKey)aKey)) + { + iData = 0; + fepMan->ClearFlag(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction); + fepMan->PtiEngine()->CancelTimerActivity(); + + return retVal; + } + + iData = aKey; + + return retVal; + } + +void TAknFepUiInputStateInitialHalfQwertyWesternPredictive::KeyTimerExpired() + { + if (iData) + { + MAknFepManagerUIInterface* fepMan = iOwner->FepMan(); + CAknFepCaseManager* caseMan = iOwner->CaseMan(); + + TAknFepInputStateInitialMultitapBase::KeyTimerExpired(); + + caseMan->UpdateCase(ENullNaviEvent); + fepMan->ClearFlag( CAknFepManager::EFlagInsideMultitapInlineEditingTransaction ); + + iData = 0; + + // if the current fn key state is FnNext, then clear it. + if( !fepMan->IsFlagSet( CAknFepManager::EFlagLongShiftKeyPress ) ) + { + if( CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState()) + { + // This cannot be done in fn manager. It should happen only + // on timer expiry -> for shift key multitapping in fn mode + // when prediction is ON. + fepMan->SetFnKeyState( CAknFepFnKeyManager::EFnKeyNone ); + } + } + } + } +void TAknFepUiInputStateInitialHalfQwertyWesternPredictive::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; + } + + // 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 + if ( !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) ) + { + shiftedCase = EPtiCaseUpper; + } + } + break; + + case EAknEditorLowerCase: + { + // Pressing shift enters uppercae letters in the "abc" mode + if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) ) + { + 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) ) + { + 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 ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) && (fnKeyState == CAknFepFnKeyManager::EFnKeyNone)) + { + shiftedCase = EPtiCaseUpper; + } + else if ( 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); + }// End of file