/*

* 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 <e32keys.h>

#include <e32svr.h> // 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 <AknFep.rsg>

#include <AknIndicatorContainer.h>  // CAknIndicatorContainer::TIndicatorContext

#include <PtiEngine.h> 

#include <PtiDefs.h>

// 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