/*

* Copyright (c) 2002-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 CAknFepManager definition

*

*/

#ifdef _DEBUG

#include <eikenv.h>

#endif

#include <fepbase.h>

#include <avkon.hrh>

#include <aknedsts.h>               //CAknEdwinState

#include "AknFepFnKeyManager.h"

#include "AknFepManager.h"

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#include "PtiEngine.h"

/*this part is removed 

const   TUid    KPhoneUidAppPhone = { 0x100058B3 };

const   TUid    KUidCalc = { 0x10005902 };

const   TUid    KUidIdle = { 0x101fd64c };

*/

const   TStdScanCode stdFnKeyCode(EStdKeyRightFunc);    // Defines the std key code for Fn key

////////////////////////////////////////////////////////////

//   CAknFepFnKeyManager implementation

//////////////////////////////////////////////////////////// 

CAknFepFnKeyManager::CAknFepFnKeyManager( CAknFepManager& aFepMan, 

                    CAknFepSharedDataInterface* aSharedDataInterface)

:iFepMan( aFepMan ),

 iFnKeyState( EFnKeyNone ),

 iIsQwertyMode (EFalse),

 iSharedDataInterface(aSharedDataInterface),

 iShiftKeyPressed( EFalse )

    {

    iIsQwertyMode = iSharedDataInterface->QwertyInputMode();

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT

    iWasPreviousModePredictive = iFepMan.WesternPredictive();

#endif // RD_INTELLIGENT_TEXT_INPUT

#else   

    iWasPreviousModePredictive = iSharedDataInterface->PredictiveTextOn();

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__     

    // The CR key KAknFepFnKeyState is reset the Fn key state NONE

    iSharedDataInterface->SetFnKeyState(0);

    }

CAknFepFnKeyManager* CAknFepFnKeyManager::NewL( CAknFepManager& aFepMan,

                                            CAknFepSharedDataInterface* aSharedDataInterface)

    {

    CAknFepFnKeyManager* self = new(ELeave) CAknFepFnKeyManager( aFepMan,aSharedDataInterface );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CAknFepFnKeyManager::~CAknFepFnKeyManager()

    {    

    iFnKeyState=EFnKeyNone;

    }

void CAknFepFnKeyManager::ConstructL()

    {    

    }

void CAknFepFnKeyManager::SetQwertyInputMode(TBool aQwertyState)

    {

    iIsQwertyMode = aQwertyState;

    }

void CAknFepFnKeyManager::ClearFnKeyState()

    {

    iFnKeyState = EFnKeyNone;

    iFepMan.UpdateIndicators();    

    }

CAknFepFnKeyManager::TFnKeyState CAknFepFnKeyManager::FnKeyState()

    {

    return iFnKeyState;

    }

void CAknFepFnKeyManager::SetFnKeyState(CAknFepFnKeyManager::TFnKeyState aState)

    {

    TPtiKeyboardType keyboardType = iFepMan.KeyboardLayout();

    //This function is only supported for EFnKeyNext and half Qwerty keypad at the moment.

    if(keyboardType == EPtiKeyboardHalfQwerty && EFnKeyNext == iFnKeyState &&

        aState == EFnKeyNone)

        {    

        //if(aState == EFnKeyNext && keyboardType == EPtiKeyboardHalfQwerty)

        //	{

        //	iFepMan.PtiEngine()->CancelTimerActivity();

        //	}

        iFnKeyState = aState;

        iFepMan.SetCase( (TCase)iPreviousCase );

        iFepMan.UpdateIndicators();

        }

#ifdef RD_INTELLIGENT_TEXT_INPUT  

    else if(keyboardType == EPtiKeyboardQwerty3x11 && EFnKeyNone == iFnKeyState &&

        aState == EFnKeyLock)

        {

        UpdatePreviousCase();

        iFnKeyState = aState;

        iFepMan.SetCase(EFnKeyLowerCase);

        iFepMan.UpdateIndicators();

        }

#endif // RD_INTELLIGENT_TEXT_INPUT 		

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__  

#ifdef RD_INTELLIGENT_TEXT_INPUT  

    //Half QWERTY state uses this to change from EFnKeyNext aFnKeyNone

 	   else if ( iFnKeyState == EFnKeyNone && aState == EFnKeyNext )

        {

        // QWERTY long press implementation uses this function to set the Fn state.

        UpdatePreviousCase();

        iFnKeyState=EFnKeyNext;

        }

#endif // RD_INTELLIGENT_TEXT_INPUT  

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

     // TODO: above piece of code should be simplify.    

     // Set the Fn Key state  

 	 else

 	    {

 	    iFnKeyState = aState;    

 	    }

    }

TKeyResponse CAknFepFnKeyManager::HandleFnKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType, 

                                                     TCoeInputCapabilities aInputCapabilities ) 

    {

    TKeyResponse keyResponse = EKeyWasNotConsumed;

    TPtiKeyboardType keyboardType = iFepMan.KeyboardLayout();

    if(!iIsQwertyMode)

        {

        return keyResponse;

        }

  	if(!iFepMan.IsFlagSet(CAknFepManager::EFlagShiftKeyDepressed) && 

      !iFepMan.IsFlagSet(CAknFepManager::EFlagLongShiftKeyPress)

      && iShiftKeyPressed )

        {

        iShiftKeyPressed = EFalse;

        }

    TInt caseFromFep = iFepMan.GetCurrentCase();

    TBool lockLater = EFalse;    

    if(  EEventKeyDown == aType )

        {

        if( stdFnKeyCode == aKeyEvent.iScanCode )

    		{

            iFepMan.PtiEngine()->CancelTimerActivity();

    		if( iPreviousKeyWasFnKey )

    			{

    			lockLater	= ETrue;

    			}

    		iPreviousKeyWasFnKey = ETrue; 			

    		}    

    	else

    		{

    		iPreviousKeyWasFnKey = EFalse; 				

    		}        

        }

    if(aKeyEvent.iRepeats && stdFnKeyCode != aKeyEvent.iScanCode &&

            iFnKeyState == EFnKeyNext)

        {

        // To fix the bug : Long press of number at the begin of editor. Then enter any character. 

        // The character is shown in upper case.

        if (ELowerCase == caseFromFep)

            {

            iFepMan.SetCase( (TCase)caseFromFep );

            }

        // To Fix Error: Character is NOT entered as per the input mode

        // when the character is entered after pressing Shift + Fn + Shift keys

        else if(!(EStdKeyRightShift == aKeyEvent.iScanCode ||

        		  EStdKeyLeftShift == aKeyEvent.iScanCode))

	        {

            iFepMan.SetCase( (TCase)iPreviousCase );	

            }

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT  

         // For QWERTY Predictive ---->

        if(iWasPreviousModePredictive)

        	{

        	// We usually end up here when using the long key press to enter Fn symbols

			iFepMan.SetWesternPredictive(ETrue); 

		   	iFepMan.TryChangeModeL(ELatin);               	

        	}

        // For QWERTY Predictive <----

#endif // RD_INTELLIGENT_TEXT_INPUT  

#endif // __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__    

        iFnKeyState = EFnKeyNone;

        iFepMan.UpdateIndicators();

        }

    if( stdFnKeyCode == aKeyEvent.iScanCode )

        {

        // Consume the function key events.

        keyResponse = EKeyWasConsumed;

        }

    if (iFepMan.IsHybridAplhaEditor())

        keyResponse = EKeyWasNotConsumed;

    // check for the case when in Half Qwerty and both shift and fn keys are

    // pressed and fn key is released while shift is still down

    if( EEventKeyUp == aType && 

    	stdFnKeyCode == aKeyEvent.iScanCode &&

    	iShiftKeyPressed &&

    	EPtiKeyboardHalfQwerty == keyboardType )

    	{

    	ClearFnKeyState();

    	}

    if( EStdKeyRightShift == aKeyEvent.iScanCode ||  EStdKeyLeftShift == aKeyEvent.iScanCode )

        {

        if( EEventKeyDown == aType ) 

            {

            iShiftKeyPressed = ETrue;

            }

        if( EEventKeyUp == aType )

            {

            iShiftKeyPressed = EFalse;

            }

        }

    // For Shift key handling.

    // Shift Key should be ignored in locked state.

    if( ( EFnKeyNext == iFnKeyState ) 

    && EEventKeyDown == aType &&

    ( EStdKeyRightShift == aKeyEvent.iScanCode ||  EStdKeyLeftShift == aKeyEvent.iScanCode)) 

        {

        // Fnkey event+ shift key event. Change to FnKey Upper case

        iFepMan.SetCase( EFnKeyUpperCase );

        if( keyboardType == EPtiKeyboardHalfQwerty )

            {

            iFepMan.SetCase( EFnKeyLowerCase );

            }

        return EKeyWasNotConsumed;

        }

    //===================================================		

	// GQF clarification Fn+Shift

	// If shift key is hold on, So fn key state should be EFnKeyNext

	// So next text mode goes to function upper

	if( aType == EEventKeyUp && iShiftKeyPressed &&  stdFnKeyCode == aKeyEvent.iScanCode)	

		{

		if( EFnKeyPressed == iFnKeyState)

			{

			iFepMan.PtiEngine()->CancelTimerActivity();

			iFnKeyState=EFnKeyNext;

			iFepMan.SetCase( EFnKeyUpperCase );				

			}			

        else if (EFnKeyPressedAgain == iFnKeyState )

            {

            CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyLock"));

            iFnKeyState = EFnKeyLock;	                

            UpdatePreviousCase();

            iFepMan.SetCase( EFnKeyUpperCase );

            }

        else if(EFnKeyDown == iFnKeyState)

            {

            iFnKeyState = EFnKeyNone;

            UpdatePreviousCase();

            iFepMan.SetCase( EUpperCase );	

            }

		iFepMan.UpdateIndicators();

		}

	// Holding shift key, press key just after releasing fn key,

	// Fn key state goes to EFnKeyNone mode.

	if( aType == EEventKeyUp && iShiftKeyPressed && iFnKeyState==EFnKeyNext && stdFnKeyCode != aKeyEvent.iScanCode &&  !(EStdKeyRightShift == aKeyEvent.iScanCode ||  EStdKeyLeftShift == aKeyEvent.iScanCode))

		{

		iFnKeyState=EFnKeyNone;		

		iFepMan.SetCase( EUpperCase );		

		iFepMan.UpdateIndicators();

		}

	//====================================================

    // Fnkey event+ shift key event -> when fn and shift key are kept pressed.

    if( (iShiftKeyPressed && EFnKeyNone != iFnKeyState ) )

        {

        if( (EFnKeyPressed == iFnKeyState) &&

        	(stdFnKeyCode != aKeyEvent.iScanCode) &&

        	!( EStdKeyRightShift == aKeyEvent.iScanCode ||  EStdKeyLeftShift == aKeyEvent.iScanCode ))

	        {

     	   	CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyDown"));

          	iFnKeyState=EFnKeyDown;	      	

	        }

        // Thre is no Functin shift reverse mode

        // So, In shift key press if fn key state is not none

        // text case stte is function upper.

        if( aType == EEventKeyDown && stdFnKeyCode == aKeyEvent.iScanCode)

        	{

        	if ( EFnKeyNext == iFnKeyState )

        		{       	     	

       	     	if(lockLater)

       	     	    {

       	     	    //CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyPressedAgain "));

       	     	    iFnKeyState=EFnKeyPressedAgain;

       	     	    } 					

        		}

        	else if ( EFnKeyLock == iFnKeyState )

	        	{

       	     	//CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyDown"));

              	iFnKeyState=EFnKeyDown;

	        	}

        	}

        iFepMan.SetCase( EFnKeyUpperCase );

        if( keyboardType == EPtiKeyboardHalfQwerty )

            {

            iFepMan.SetCase( EFnKeyLowerCase );

            }

        iFepMan.UpdateIndicators();

        return EKeyWasNotConsumed;

        }

    // Check the input mode of the currently focused editor (when available)

    MCoeFepAwareTextEditor* fepAwareTextEditor = aInputCapabilities.FepAwareTextEditor();

    if ( fepAwareTextEditor && fepAwareTextEditor->Extension1() )

        {

        if( EAknEditorNumericInputMode == 

            ( static_cast<CAknEdwinState*>( fepAwareTextEditor->Extension1()->State( KNullUid ) ) )->CurrentInputMode() )

            // If number input mode is detected, handle it as number input

            // capability with greatest available variation of letters

            {

            // Use EDialableCharacters since it provides most flexibility for number input

            aInputCapabilities.SetCapabilities( TCoeInputCapabilities::EDialableCharacters );

            }            

        }

    if ( EFnKeyForced != iFnKeyState )

        {

        // Handling of Fn key events.

        // If Fn key is held down while characters are typed, all following key 

        // events are exchanged.

        // If Fn key is only pressed (key down + key up, not held down), only

        // the very next key event is exchanged.

        // If the next key event after Fn key is another Fn key event, the 

        // Fn lock mode is activated. Then all following key events are

        // exchanged until the Fn key is pressed again.       

        if( EEventKeyDown == aType && stdFnKeyCode == aKeyEvent.iScanCode )

            {

            if ( EFnKeyNext == iFnKeyState )

                {                

                if(lockLater)

            		{

            		CEikonEnv::Static()->InfoMsg(_L("iFnKeyState=EFnKeyPressedAgain"));	

            		iFnKeyState=EFnKeyPressedAgain;

          			}

              	else

              	    {

              	    iFnKeyState=EFnKeyPressed;

              	    }		              			

                }

            else if ( EFnKeyLock == iFnKeyState )

                {

                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState=EFnKeyDown"));

                iFnKeyState=EFnKeyDown;

                }

            //else 

            // Sahoo

            else if ( EFnKeyDown != iFnKeyState )

                {

                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState=EFnKeyPressed"));

                iFnKeyState=EFnKeyPressed;

                }

            iFepMan.UpdateIndicators();    

            return keyResponse;

            }

        // Sahoo            

        if( EEventKeyDown == aType && EFnKeyPressed == iFnKeyState )

            {

            iFnKeyState=EFnKeyDown;

            iFepMan.SetCase( EFnKeyLowerCase );

            }

#ifdef __WINS        

        // NOTE: This following HACK is to ensure working in emulator environment,

        // where Alt Gr key seems to send always two separate key events:

        // EStdKeyRightFunc and EStdKeyLeftCtrl

        if ( EStdKeyLeftCtrl == aKeyEvent.iScanCode )

            {

            return;

            }

        // HACK ends

#endif

        if( EEventKeyUp == aType && stdFnKeyCode == aKeyEvent.iScanCode )

            {

            if ( EFnKeyPressedAgain == iFnKeyState )

                {

               	if(! iFepMan.IsFlagSet(CAknFepManager::EFlagQwertyShiftMode))

	               	{

	                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyLock"));

	                iFnKeyState = EFnKeyLock;

		           	}

               	else

	               	{

	                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyNext"));

	                iFepMan.PtiEngine()->CancelTimerActivity();

	                iFnKeyState = EFnKeyNext;               		

	               	}

                UpdatePreviousCase();

                iFepMan.ClearFlag(CAknFepManager::EFlagQwertyShiftMode);             

                iFepMan.SetCase( EFnKeyLowerCase );

                }

            else if ( EFnKeyPressed == iFnKeyState )

                {

                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyNext"));

                iFepMan.PtiEngine()->CancelTimerActivity();

                iFnKeyState = EFnKeyNext;

                UpdatePreviousCase();

                // After pressing shift key Press Fn key,

                // So its goes to function upper mode

                if( iFepMan.IsFlagSet(CAknFepManager::EFlagQwertyShiftMode))

                	iFepMan.SetCase( EFnKeyUpperCase );

                else

                    iFepMan.SetCase( EFnKeyLowerCase );

                }

            else

                {

                CEikonEnv::Static()->InfoMsg(_L("iFnKeyState = EFnKeyNone"));

                // For Shift key handling.

                if( EFnKeyDown == iFnKeyState || EFnKeyNext == iFnKeyState )

                    {

                    iFepMan.SetCase( (TCase)iPreviousCase );

                    }

                iFnKeyState = EFnKeyNone;

                }

            if( EEventKeyUp == aType && iFnKeyState == EFnKeyNone )

                {

                // To fix the bug :Fn key lock. then type a number with short press at begin of 

                // editor. Now press Fn key to go to Fn none state. 

                // Press a character. The char is in upper case

                if (ELowerCase == caseFromFep)

		            {

		            iFepMan.SetCase( (TCase)caseFromFep );

		            }

		        // To Fix Error: Character is NOT entered as per the input mode

		        // when the character is entered after pressing Shift + Fn + Shift keys

		        else if(!(EStdKeyRightShift == aKeyEvent.iScanCode ||

		            	  EStdKeyLeftShift == aKeyEvent.iScanCode))

		            {

		            iFepMan.SetCase( (TCase)iPreviousCase );	

		            }

                }

            iFepMan.UpdateIndicators();

            return keyResponse;

            }

        }

    // Now detect the input mode for telephone and calculator apps

/*    if ( aInputCapabilities.IsNone() )

        {   // Idle and Calculator do not provide input capabilities at all.

        if ( KPhoneUidAppPhone == aCurrentTopAppUid || KUidIdle == aCurrentTopAppUid )

            {

            aInputCapabilities.SetCapabilities( TCoeInputCapabilities::EDialableCharacters );

            }

        if ( aCurrentTopAppUid == KUidCalc )

            {

            aInputCapabilities.SetCapabilities( TCoeInputCapabilities::EWesternNumericReal );

            }

        }        

*/        

    // Now handle the automatic number mode

    if ((iFnKeyState != EFnKeyForced) && 

        ( aInputCapabilities.SupportsWesternNumericIntegerPositive() ||

         aInputCapabilities.SupportsWesternNumericIntegerNegative() ||

         aInputCapabilities.SupportsWesternNumericReal() ||

         aInputCapabilities.SupportsDialableCharacters() )         

       )

        {

        // If input mode is numeric, Fn key is automated (=forced)

        iFnKeyState = EFnKeyForced;

        UpdatePreviousCase();