/*

* 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:           

*

*/

#include "AknFepHashKeyManager.h"

#include "AknFepManager.h"

#include "AknFepCaseManager.h"

#include "AknFepUiIndicInputManager.h"

#include <aknedsts.h>

#include <uikon.hrh>

#include <coedef.h>

#include <PtiEngine.h>

//move to class definition

#define EHashKeyTimeout 700000 // 0.7s

CAknFepHashKeyManager* CAknFepHashKeyManager::NewL(CAknFepManager& aFepMan, 

                                                   CAknFepCaseManager* aCaseMan)

    {

    CAknFepHashKeyManager* self = new(ELeave) CAknFepHashKeyManager(aFepMan, aCaseMan);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CAknFepHashKeyManager::~CAknFepHashKeyManager()

    {

    delete iHashKeyTimer;

    }

TKeyResponse CAknFepHashKeyManager::HandleKeyEventL(TKeyPressLength aLength)

    {

    TKeyResponse response = EKeyWasNotConsumed;

    switch (iHashKeyStyle)

        {

        case EHashKeyStyleWestern:

            response = HandleKeyWesternL(aLength);

            break;

        case EHashKeyStyleChineseWithWestern:

            response = HandleKeyWesternWithChineseL(aLength);

            break;

        case EHashKeyStyleJapanese:

            response = HandleKeyJapaneseL(aLength);

            break;

        case EHashKeyStyleKoreanWithWestern:

            response = HandleKeyWesternWithKoreanL(aLength);

            break;

    default:

        break;

        }

    return response;

    }

void CAknFepHashKeyManager::SetMode(TInt aMode, TBool aWesternPredictive)

    {

    iMode = aMode;

    iWesternPredictive = aWesternPredictive;

    }

void CAknFepHashKeyManager::SetHashKeyStyle(THashKeyStyle aHashKeyStyle)

    {

    iHashKeyStyle = aHashKeyStyle;

    }

void CAknFepHashKeyManager::CancelHashKeyTimer()

    {

    if (iHashKeyTimer->IsActive())

        {

        iHashKeyTimer->Cancel();

        }

    }

CAknFepHashKeyManager::CAknFepHashKeyManager(CAknFepManager& aFepMan, CAknFepCaseManager* aCaseMan)

    :iHashKeyStyle(EHashKeyStyleWestern),

     iFepMan(aFepMan),

     iCaseMan(aCaseMan)

    {

    iLanguageChangedOrChangeFromNumberMode = EFalse;

    iIndicSelectionLoopIndex = -1; // Cannot use 'iFepMan.WesternPredictive(ELatin);' since FepMan is not completely constructed at the construction of this

    }

void CAknFepHashKeyManager::ConstructL()

    {   

    iHashKeyTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    }

TInt CAknFepHashKeyManager::HashKeyTimerTimeoutCallback(TAny* aObj)

    {

    STATIC_CAST(CAknFepHashKeyManager*, aObj)->HashKeyTimerTimeout();

    return KErrNone;

    }

void CAknFepHashKeyManager::HashKeyTimerTimeout()

    {

    iHashKeyTimer->Cancel();

    }

void CAknFepHashKeyManager::RevertPredictiveTextSettingChangeL()

    {

    if ( !iFepMan.InputLanguageSupportsCaseChanges() && iFepMan.EditorState()&&

        !( iFepMan.EditorState()->Flags() & EAknEditorFlagNoT9) )

        {

        // Reverts predictive text settings change made with short key press.

        iFepMan.SetWesternPredictive( !iFepMan.WesternPredictive(ELatin) );

        iFepMan.TryChangeModeL(ELatin);

        }

    }

TKeyResponse CAknFepHashKeyManager::HandleKeyWesternL(TKeyPressLength aLength)

    {

    TKeyResponse response = EKeyWasNotConsumed;

    TBool phoneIdle = (iFepMan.EditorType() == CAknExtendedInputCapabilities::EPhoneNumberEditor); 

        {

        return response;

        }

    iLastModeNumber = (iMode == ENumber || iMode == ENativeNumber);

    if ( (iMode == ENumber || iMode == ENativeNumber) && !iFepMan.HashKeySelectionInUse())

        {

        if (aLength == ELongKeyPress)

            {

            // Clear the EExtendedFlagShortPressHashKey, only for non numeric only editors

            // so as to indicate we are in a long press of hash key event.

            // In case of numeric only editor, we should re-simulate hash and let application 

            // handle it.

            if ( !iFepMan.IsOnlyNumericPermitted() )

                {

                iFepMan.ClearExtendedFlag(CAknFepManager::EExtendedFlagShortPressHashKey);

                // Long press of hash key switches to alpha mode

                // if it is permitted mode in the editor.

                iFepMan.TryChangeToModeBeforeL();

                ResetIndicHashKeyStateL();

                }

            response = EKeyWasConsumed;

            }

        else if (!iFepMan.IsExtendedFlagSet(CAknFepManager::EExtendedFlagShortPressHashKey))

            {

            // Set the flag to indicate its a short press of key event

            iFepMan.SetExtendedFlag(CAknFepManager::EExtendedFlagShortPressHashKey);

            response = EKeyWasConsumed;

            }

        else

            {

            // We are not suppose to be here. Just a fail safe check to guard us against

            // erroneous situations.

            iFepMan.ClearExtendedFlag(CAknFepManager::EExtendedFlagShortPressHashKey);

            }

        }

    else

        {

        if ( aLength == EShortKeyPress )

            {

           	if (iFepMan.HashKeySelectionInUse())

             	{

            	// New style hash key loop when long hash-key press is used for text selection.												     			                	               	

#ifndef RD_INTELLIGENT_TEXT_INPUT

		        // To rip off suggested word completion when user wants to 

		        // switch to number or multitap mode

		        if(iFepMan.IsAutoCompleteOn())

		        	{

		            iFepMan.RemoveSuggestedCompletionL();	

		            }

#endif	//RD_INTELLIGENT_TEXT_INPUT

               	return HandleKeyWesternSelectionStyleL(aLength);  

               	}

 			if ( iLastModeNumber )

            	{

            	// The key should not be consumed in number mode? FEP Manager may

            	// put special chars into the editor or the key  event 

            	// is passed to the editor.

	            // But now the event is consumed. Same happens also in 

    	        // Chinese languages because # key is reserved for 

        	    // other purpose.

            	response = EKeyWasConsumed;

           		 }               	

			if(IsIndicHashKeyStyleRequired())

				{

				return (SetIndicStateL());	

				}

            	// Traditional hash key loop

            if ( iFepMan.InputLanguageSupportsCaseChanges() )

                {

                if (iHashKeyTimer->IsActive())

                    {

                    iHashKeyTimer->Cancel();

                    iCaseMan->RevertCaseChange();

                    // Toggle predictive setting.

#ifndef RD_INTELLIGENT_TEXT_INPUT

		         // To rip off suggested word completion when user wants to 

		         // switch to number or multitap mode

		        if(iFepMan.IsAutoCompleteOn())

		        	{

		            iFepMan.RemoveSuggestedCompletionL();	

		            }

#endif	//RD_INTELLIGENT_TEXT_INPUT

                    iFepMan.SetCcpuFlag(CAknFepManager::ECcpuStataCommitPredictiveWord);

                    iFepMan.SetWesternPredictive( !iFepMan.WesternPredictive(ELatin) );

                    iFepMan.TryChangeModeL(ELatin);

                    }

                else

                    {

                    iCaseMan->ManualCaseUpdate();

                    iHashKeyTimer->Start(EHashKeyTimeout, EHashKeyTimeout,

                        TCallBack(HashKeyTimerTimeoutCallback, this));

                    }

                }

            else // Case changes are not allowed.

                {

                if (iHashKeyTimer->IsActive())

                    {

                    iHashKeyTimer->Cancel();

                    // Double press of hash key does not have functionality.

                    }

                else

                    {

                    // Toggle predictive setting.

#ifndef RD_INTELLIGENT_TEXT_INPUT

                    // AutoComplete - Fix - Begin

                    if(iFepMan.IsAutoCompleteOn())

		        	{

		            iFepMan.RemoveSuggestedCompletionL();	

		            }

		            // AutoComplete - Fix - End

#endif	//RD_INTELLIGENT_TEXT_INPUT

                    iFepMan.SetWesternPredictive( !iFepMan.WesternPredictive(ELatin) );

                    iFepMan.TryChangeModeL(ELatin);

                    iHashKeyTimer->Start(EHashKeyTimeout, EHashKeyTimeout,

                        TCallBack(HashKeyTimerTimeoutCallback, this));

                    }

                }

            response = EKeyWasConsumed;

            }

        else // Long key press of hash key

            {

            // Clear EExtendedFlagShortPressHashKey flag as soon as long press happens

            iFepMan.ClearExtendedFlag(CAknFepManager::EExtendedFlagShortPressHashKey);

            // Toggle number mode / alpha mode

            if (iLastModeNumber && !IsIndicHashKeyStyleRequired() && 

               !iFepMan.HashKeySelectionInUse())	// For Indic it is handled in SetIndicPreviousStateL()

                {

                // If short hash key press event is passed to the editor, it

                // needs to be removed here from the editor.

                iFepMan.TryChangeToModeBeforeL();

                }

            else

                {

                // Input mode is incremented.

                if (!iFepMan.HashKeySelectionInUse())

                	{

#ifndef RD_INTELLIGENT_TEXT_INPUT

                	// To rip off suggested word completion when user wants to switch to number mode

                	if(iFepMan.IsAutoCompleteOn())

                		{

                		iFepMan.RemoveSuggestedCompletionL();	

                		}

#endif	//RD_INTELLIGENT_TEXT_INPUT

						if(IsIndicHashKeyStyleRequired())

							{

							SetIndicPreviousStateL();	

							}					    	

						else

							{

							RevertPredictiveTextSettingChangeL();			

							}                	

                        if( iFepMan.IsSupportNativeNumber())

                            {

                            iFepMan.TryChangeModeL( ENativeNumber );  

                            }

                        else

                            {

                            iFepMan.TryChangeModeL( ENumber );    

                            }

                	}

				else if (!iFepMan.IsCcpuFlagSet(CAknFepManager::ECcpuStateEdwinInSelectionMode) &&

				         iFepMan.OkToActivateSelectionMode())							

					{											

					// User wants to select and not to change mode, so cancel the mode change

					// caused by initial hash key press.

					if(iLastModeNumber && !IsIndicHashKeyStyleRequired())

						{

						iFepMan.TryChangeToModeBeforeL();		

						}

					else

						{

						SetPreviousSelectionStyleModeL();		

						}

					iFepMan.SetCcpuFlag(CAknFepManager::ECcpuStateHashDown |

					                    CAknFepManager::ECcpuStateEdwinInSelectionMode |

					                    CAknFepManager::ECcpuStateHashKeyDeleteDone );

					 TKeyEvent ccpuStart = {EKeyF21, EStdKeyF21, 0, 0};

        			// to enable copy/paste support on cba. We simulate via CCoeEnv

        			// to avoid fep SimulateKeyEventL adding shift modifiers

        			CCoeEnv::Static()->SimulateKeyEventL(ccpuStart, EEventKey);					

					}                	

                }            

            response = EKeyWasConsumed;

            }

        }              

    return response;

    }

TKeyResponse CAknFepHashKeyManager::HandleKeyWesternWithChineseL(TKeyPressLength aLength)

    {

    TKeyResponse response = EKeyWasNotConsumed;

    if ( iFepMan.IsOnlyNumericPermitted() )

        {

        if ( aLength == ELongKeyPress )

            {

            response = EKeyWasConsumed;

            if ( iFepMan.HashKeySelectionInUse() )

                {

                TText prevCh = iFepMan.PreviousChar();

                if (prevCh == '#')

                    {

                    iFepMan.RemovePreviousCharacterL();             

                    }

                }

    		iFepMan.SetCcpuFlag( CAknFepManager::ECcpuStateHashDown | 

    		                    CAknFepManager::ECcpuStateEdwinInSelectionMode );

    		TKeyEvent ccpuStart = { EKeyF21, EStdKeyF21, 0, 0 };

    		// to enable copy/paste support on cba. We simulate via CCoeEnv

    		// to avoid fep SimulateKeyEventL adding shift modifiers

    		CCoeEnv::Static()->SimulateKeyEventL( ccpuStart, EEventKey );

            }

        //else let the FEP Man put special chars into the editor

        }

    else

        {

        if (aLength == EShortKeyPress)

            {

            if (iMode == ENumber || iMode == ENativeNumber)

                {

                iLastModeNumber = ETrue;

                }

            else

                {

                iLastModeNumber = EFalse;

                }            

            CAknEdwinState* editorState = iFepMan.EditorState();                    

            TInt permittedCases = editorState->PermittedCases();

            permittedCases = permittedCases == 0 ? 

                EAknEditorLowerCase | EAknEditorUpperCase : permittedCases;

            if ( iMode == ELatin && (permittedCases & EAknEditorTextCase))

                {

                // Latin case update is changed back to automatic if latin 

                // text case is allowed and the case is changed manually from #-key.

                iFepMan.ClearFlag(CAknFepManager::EFlagSupressAutoUpdate);

                }

            TInt currentCase = iCaseMan->CurrentCase();

            // Is current latin case last available case.

            TBool lastCase = ( ( !(permittedCases & EAknEditorTextCase) && 

                  (( currentCase == EAknEditorLowerCase) ||

                   ( currentCase == EAknEditorUpperCase && 

                   !(permittedCases & EAknEditorLowerCase)) ) ||

                ( editorState->Flags() & EAknEditorFlagFixedCase) ) ||

                ( editorState->Flags() & EAknEditorFlagForceTransparentFepModes) );

            if (iMode == ELatin && 

                !iFepMan.IsFlagSet(CAknFepManager::EFlagChangeInputMode) &&

                !lastCase )

                {

                // Input mode is still Latin. Only case is updated.

                if (permittedCases & EAknEditorTextCase) 

                    {

                    iCaseMan->ManualCaseUpdate();

                    }

                else

                    {

                    iCaseMan->SetCurrentCase(EAknEditorLowerCase);

                    }

                // Next time input mode is changed if any text is not entered before.

                iFepMan.SetFlag(CAknFepManager::EFlagChangeInputMode);

                }

            else

                {

                // Input mode is incremented.

                iFepMan.TryIncrementModeL(iMode);

                iFepMan.ClearFlag(CAknFepManager::EFlagChangeInputMode);

                if (iMode == ELatin) // New mode after Increment.

                    {

                    if (editorState->Flags() & EAknEditorFlagFixedCase) 

                        {

                        // Only one fixed case is available. Use it.

                        iCaseMan->ConfigureCaseStateFromEditorState();

                        iFepMan.SetFlag(CAknFepManager::EFlagChangeInputMode);

                        }

                    else if (editorState->Flags() & EAknEditorFlagForceTransparentFepModes) 

                        {

                        // Only lower case is used with find pane.

                        iCaseMan->SetCurrentCase(EAknEditorLowerCase);

                        iFepMan.SetFlag(CAknFepManager::EFlagSupressAutoUpdate);

                        iFepMan.SetFlag(CAknFepManager::EFlagChangeInputMode);

                        }

                    else if (permittedCases & EAknEditorTextCase)

                        {

                        iCaseMan->SetCurrentCase(EAknEditorTextCase);

                        iCaseMan->UpdateCase(ENullNaviEvent);

                        }

                    else

                        {

                        if (permittedCases & EAknEditorUpperCase)

                            {

                            iCaseMan->SetCurrentCase(EAknEditorUpperCase);

                            if ( !(permittedCases & EAknEditorLowerCase))

                                {

                                // We need to move to next input mode since only upper case 

                                // is permitted in Latin input mode.

                                iFepMan.SetFlag(CAknFepManager::EFlagChangeInputMode);

                                }

                            }

                        else

                            {

                            iCaseMan->SetCurrentCase(EAknEditorLowerCase);

                            iFepMan.SetFlag(CAknFepManager::EFlagChangeInputMode);

                            }

                        }

                    }

                }

            }

        else // Long keypress

            {

			if (!iFepMan.HashKeySelectionInUse())            

				{							

            	if (iLastModeNumber)

                	{

                	iFepMan.TryChangeToModeBeforeL();

                	}

            	else

                	{

                	if( iFepMan.IsSupportNativeNumber())

                	    {

                	    iFepMan.TryChangeModeL( ENativeNumber );

                	    }

                	else

                	    {

                	    iFepMan.TryChangeModeL(ENumber);

                	    }

                	}

				}

			else if (!iFepMan.IsCcpuFlagSet(CAknFepManager::ECcpuStateEdwinInSelectionMode) &&

			         iFepMan.OkToActivateSelectionMode())							

				{							

				// User wants to select and not to change mode, so cancel the mode change

				// caused by initial hash key press. 			

				MPtiLanguage* lang = iFepMan.PtiEngine()->CurrentLanguage();

				TInt inputLang = ELangTest;

				if (lang)

					{

					inputLang = lang->LanguageCode();	

					}

				const TInt inputMode = iFepMan.InputMode();				

				if ((inputLang == ELangPrcChinese && inputMode == EPinyin) ||

				    (inputLang == ELangTaiwanChinese && inputMode == EZhuyin) ||

				    (inputLang == ELangHongKongChinese && inputMode == EStroke))												

					{

					// Hash key selection was initiated from number mode,

					// return there.

					iFepMan.TryChangeModeL(ENumber);						

					}

				else

				    {

			   		iFepMan.TryChangeToModeBeforeL();							

					}

				iFepMan.SetCcpuFlag(CAknFepManager::ECcpuStateHashDown | 

				                    CAknFepManager::ECcpuStateEdwinInSelectionMode );

				 TKeyEvent ccpuStart = {EKeyF21, EStdKeyF21, 0, 0};

        		// to enable copy/paste support on cba. We simulate via CCoeEnv

        		// to avoid fep SimulateKeyEventL adding shift modifiers

        		CCoeEnv::Static()->SimulateKeyEventL(ccpuStart, EEventKey);					

				}                		

            }

        response = EKeyWasConsumed;

        }

    return response;

    }

TKeyResponse CAknFepHashKeyManager::HandleKeyJapaneseL(TKeyPressLength aLength)

    {