1 /*

     2 * Copyright (c) 2002 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 TAknFepInputStateInitialHalfQwertyWesternPredictive methods.

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 

    30 #include "AknFepUiInputStateInitialHalfQwertyWesternPredictive.h"

    31 #include "AknFepUIManagerStateInterface.h"      //MAknFepUIManagerStateInterface

    32 #include "AknFepManagerUIInterface.h"           //MAknFepManagerUIInterface

    33 #include "AknFepManager.h"

    34 #include "AknFepCaseManager.h"                  //CAknFepCaseManager

    35 

    36 #include <PtiDefs.h>

    37 #include <PtiEngine.h>

    38 

    39 // TODO: Remove this include

    40 #include <AvkonInternalCRKeys.h>

    41 static const TInt KKeyMappingsLength = 32;

    42 TAknFepUiInputStateInitialHalfQwertyWesternPredictive::TAknFepUiInputStateInitialHalfQwertyWesternPredictive(MAknFepUIManagerStateInterface* aOwner)

    43     //:TAknFepInputStateBase(aOwner),

    44     :TAknFepInputStateInitialMultitapBase(aOwner)

    45     {

    46     iData = 0;

    47     CPtiEngine* ptiengine = iOwner->PtiEngine();

    48 	// this is already being done in the base constructor

    49 	// should not be done again

    50 //    TPtiTextCase caseMode = ptiengine->Case();

    51 //    ptiengine->ClearCurrentWord();

    52 //    ptiengine->SetCase(caseMode);

    53     ptiengine->SetInputMode( EPtiEngineHalfQwerty );

    54     }

    55 

    56 TBool TAknFepUiInputStateInitialHalfQwertyWesternPredictive::HandleKeyL(TInt aKey, TKeyPressLength aLength)

    57     {

    58     MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    59     

    60     TBool retVal = EFalse;

    61     TBuf<KKeyMappingsLength> mappedCharacters;

    62     if (iData && (iData != aKey) && fepMan->IsFlagSet(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction))

    63         {

    64         iOwner->PtiEngine()->CancelTimerActivity();        

    65         fepMan->CommitInlineEditL();      

    66         iOwner->PtiEngine()->ClearCurrentWord();        

    67         fepMan->ClearFlag(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction);             

    68         iData = 0;

    69         // if the current fn key state is FnNext, then clear it.

    70         if( !fepMan->IsFlagSet( CAknFepManager::EFlagLongShiftKeyPress ) )

    71             {

    72             if( CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState())

    73                 {

    74                 fepMan->SetFnKeyState( CAknFepFnKeyManager::EFnKeyNone );

    75                 }

    76             }

    77         }

    78     HandleShiftState(aKey);

    79     if((fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed))&& (aKey !=EStdKeyBackspace) && (aKey!=EKeyBackspace))

    80         {

    81         if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) )

    82             {

    83             fepMan->TryRemoveNoMatchesIndicatorL();

    84             }      

    85         if (fepMan->IsAutoCompleteOn())

    86             {

    87             TInt tailLength = 0;

    88             iOwner->PtiEngine()->HandleCommandL( EPtiCommandGetAutoCompletionTailLength, &tailLength );

    89             if(tailLength > 0)

    90                 {

    91 				// To remove the autocompletion part, the below function is used. 

    92 				// DeleteKeyPress was used earlier. This is removed to fix the bug :

    93 				// enter characters to show autocompletion part. Now press a 

    94 				// character so that the no matches character is shown. Now press

    95                 // backspace key, last character is not deleted.

    96                 fepMan->RemoveSuggestedAdvanceCompletionL();                

    97                 return ETrue;

    98                 }

    99             }

   100         // for long key press do not go to multitap base

   101         if( EShortKeyPress == aLength )

   102         	{

   103         	TAknFepInputStateInitialMultitapBase::HandleKeyL(aKey, aLength);

   104         	}        	

   105         else

   106         	{		

   107         	mappedCharacters.Zero();	

   108 	        iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey

   109 	        					, mappedCharacters, iOwner->PtiEngine()->Case());

   110 	        fepMan->NewCharacterL(mappedCharacters);

   111 	        fepMan->CommitInlineEditL();        

   112         	}

   113      // cancel the multitap timer if only one character is mapped to it   

   114 		mappedCharacters.Zero();

   115 		

   116         iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey, mappedCharacters, iOwner->PtiEngine()->Case());

   117         

   118         if( mappedCharacters.Length() < 2 )

   119             {

   120             iOwner->PtiEngine()->CancelTimerActivity(); 

   121             }

   122             

   123         iData = aKey;

   124         fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringChrKeyPress);

   125         return ETrue;

   126         }

   127 	// for long press of punct key, a stream of characters mapped to 

   128 	// that case should be shown both in predictive and non-predictive mode	

   129     if ( aLength == ELongKeyPress && aKey == EStdKeyFullStop )    

   130     	{

   131     	// Long press should always input fnlower character

   132     	iOwner->PtiEngine()->SetCase( EPtiCaseFnLower);

   133     	

   134     	mappedCharacters.Zero();

   135         iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey

   136         					, mappedCharacters, iOwner->PtiEngine()->Case());

   137         fepMan->NewCharacterL(mappedCharacters);

   138         fepMan->CommitInlineEditL();        

   139         return ETrue;

   140    		}

   141     switch (aKey)

   142         {

   143         case EStdKeyLeftShift:

   144         case EStdKeyRightShift:

   145         case EStdKeyLeftFunc:

   146             {

   147             // Handle shift key seperately only if fn state is set.

   148             if( CAknFepFnKeyManager::EFnKeyPressed == fepMan->FnKeyState() ||

   149                       CAknFepFnKeyManager::EFnKeyDown == fepMan->FnKeyState() ||

   150                       CAknFepFnKeyManager::EFnKeyForced == fepMan->FnKeyState() || 

   151                       CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState() || 

   152                       CAknFepFnKeyManager::EFnKeyPressedAgain == fepMan->FnKeyState() ||

   153                       CAknFepFnKeyManager::EFnKeyLock == fepMan->FnKeyState())

   154                 {

   155                 fepMan->PtiEngine()->SetCase( EPtiCaseFnLower );

   156                 TAknFepInputStateInitialMultitapBase::HandleKeyL(aKey, aLength);

   157 				// cancel the multitap timer if only one character is mapped to it   

   158 				mappedCharacters.Zero();

   159         		iOwner->PtiEngine()->MappingDataForKey((TPtiKey)aKey, mappedCharacters, iOwner->PtiEngine()->Case());

   160         

   161         		if( mappedCharacters.Length() < 2 )

   162             		{

   163             		iOwner->PtiEngine()->CancelTimerActivity(); 

   164             		}

   165                 }

   166             }

   167             break;

   168             

   169         case EStdKeyNull:

   170             // Take no action if simulated key ends up here

   171             break;

   172             

   173         case EStdKeySpace: //fall through

   174             {

   175         	_LIT(KSpace," "); 

   176         	if( fepMan->FnKeyState() == CAknFepFnKeyManager::EFnKeyNone)               

   177         		{

   178 				fepMan->StartInlineEditL();

   179 	            fepMan->UpdateInlineEditL(KSpace,0);

   180 	            fepMan->CommitInlineEditL();

   181 	        	return ETrue;        		

   182         		}

   183         	else

   184 	        	{

   185 	            // Most keys activate the entry state and are handled there

   186 	            fepMan->TryCloseUiL(); //expires the multitap timer

   187 	            iOwner->ChangeState(EEntry);

   188 	            fepMan->SendUIActivatedNotification();

   189 	            }

   190         	break;	

   191 	        }

   192         case EStdKeyEnter:

   193         case EStdKeyTab:

   194         case EStdKeyBackspace:

   195         case EStdKeyLeftArrow:

   196         case EStdKeyRightArrow:

   197         case EStdKeyUpArrow:

   198         case EStdKeyDownArrow:

   199             {

   200             // Navigation keys do not activate the entry state. Instead they are handled by the editor directly.

   201             

   202             // Asyncronous case update is needed after the editor has handled the key

   203             fepMan->SimulateKeyEventL(EKeyF19); 

   204             if (((aKey == EStdKeyBackspace) || (aKey == EKeyBackspace)) &&  (fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed)))

   205                 fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringChrKeyPress);

   206             }

   207             break;

   208         default:        

   209             {

   210             // Most keys activate the entry state and are handled there

   211             fepMan->TryCloseUiL(); //expires the multitap timer

   212             iOwner->ChangeState(EEntry);

   213             fepMan->SendUIActivatedNotification();

   214             }

   215         }

   216     

   217     if ( aKey == EStdKeyEnter)

   218         {

   219         iData = 0;

   220         return 0;

   221         }

   222     if( !iOwner->PtiEngine()->IsValidKey((TPtiKey)aKey))

   223     	{

   224     	iData = 0;

   225         fepMan->ClearFlag(CAknFepManager::EFlagInsideMultitapInlineEditingTransaction);        

   226         fepMan->PtiEngine()->CancelTimerActivity();

   227                 

   228         return retVal;

   229     	}

   230     

   231     iData = aKey;

   232     

   233     return retVal;

   234     }

   235 

   236 void TAknFepUiInputStateInitialHalfQwertyWesternPredictive::KeyTimerExpired()

   237     {

   238     if (iData)

   239         {

   240         MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

   241         CAknFepCaseManager* caseMan = iOwner->CaseMan();

   242         

   243         TAknFepInputStateInitialMultitapBase::KeyTimerExpired();

   244         

   245         caseMan->UpdateCase(ENullNaviEvent); 

   246         fepMan->ClearFlag( CAknFepManager::EFlagInsideMultitapInlineEditingTransaction );

   247         

   248         iData = 0;

   249         

   250         // if the current fn key state is FnNext, then clear it.

   251         if( !fepMan->IsFlagSet( CAknFepManager::EFlagLongShiftKeyPress ) )

   252             {

   253             if( CAknFepFnKeyManager::EFnKeyNext == fepMan->FnKeyState())

   254                 {

   255                 // This cannot be done in fn manager. It should happen only

   256                 // on timer expiry -> for shift key multitapping in fn mode 

   257                 // when prediction is ON.

   258                 fepMan->SetFnKeyState( CAknFepFnKeyManager::EFnKeyNone );

   259                 }

   260             }

   261         }

   262     }

   263 void TAknFepUiInputStateInitialHalfQwertyWesternPredictive::HandleShiftState( TInt aKey )

   264     {

   265     MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

   266     CPtiEngine* ptiengine = iOwner->PtiEngine();

   267     CAknFepCaseManager* caseMan = iOwner->CaseMan();

   268     CAknFepFnKeyManager::TFnKeyState fnKeyState  = fepMan->FnKeyState();

   269     TPtiTextCase shiftedCase;

   270     if(fnKeyState  != CAknFepFnKeyManager::EFnKeyNone)

   271         {

   272         shiftedCase = EPtiCaseFnLower;

   273         }

   274     else

   275         {

   276         shiftedCase= EPtiCaseLower; 

   277         }

   278     

   279     // Find out if the key is alphabetic

   280     TBuf<KKeyMappingsLength> keyMappings; 

   281     ptiengine->MappingDataForKey( (TPtiKey)aKey, keyMappings, EPtiCaseUpper );   

   282     TBool isAlpha = ( keyMappings.Length() && TChar(keyMappings[0]).IsAlpha() );

   283     

   284     if (isAlpha && (fnKeyState  == CAknFepFnKeyManager::EFnKeyNone))

   285         {

   286         switch ( caseMan->CurrentCase() )

   287             {

   288             case EAknEditorTextCase:

   289                 {

   290                 // Alphabetic characters are always capitalized in "Abc" mode 

   291                 // unless the shift is pressed

   292                 if ( !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) )

   293                     {

   294                     shiftedCase = EPtiCaseUpper;

   295                     }          

   296                 }

   297             break;

   298             

   299             case EAknEditorLowerCase:

   300                 {

   301                 // Pressing shift enters uppercae letters in the "abc" mode

   302                 if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) )

   303                     {

   304                     shiftedCase = EPtiCaseUpper;

   305                     }                

   306                 }

   307             break;

   308             

   309             case EAknEditorUpperCase:

   310                 {

   311                 // In the "ABC" mode (capslock mode) the letters are uppercased

   312                 // unless the shift is pressed

   313                 if ( !fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) )

   314                     {

   315                     shiftedCase = EPtiCaseUpper;

   316                     }                

   317                 }

   318             break;

   319                 

   320             default:

   321             break;

   322             }

   323 

   324         

   325         }

   326     else

   327         {

   328         // non-alphabetic keys are shifted if and only if shift is pressed, no matter what is the input state

   329         if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) && (fnKeyState  == CAknFepFnKeyManager::EFnKeyNone))

   330             {

   331             shiftedCase = EPtiCaseUpper;

   332             }

   333         else if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyShiftMode) && (fnKeyState  != CAknFepFnKeyManager::EFnKeyNone))

   334             {

   335             shiftedCase = EPtiCaseFnUpper;

   336             }    

   337         }

   338 

   339     

   340     // Handle the Chr key state

   341     if ( fepMan->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) )

   342         {

   343         // Chr key is pressed down. Chr mode is used.

   344         if (shiftedCase == EPtiCaseLower)

   345             {

   346             shiftedCase = EPtiCaseChrLower;

   347             }

   348         else if (shiftedCase == EPtiCaseUpper)

   349             {

   350             shiftedCase = EPtiCaseChrUpper;

   351             }

   352         }

   353     

   354     ptiengine->SetCase(shiftedCase);

   355     

   356     fepMan->ClearFlag(CAknFepManager::EFlagNoActionDuringShiftKeyPress);

   357     }// End of file