/*

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

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include "AknFepManager.h"

#include "AknFepManagerInterface.h" // MAknFepManagerInterface

#include "aknfepindicator.h"

#include "AknFepPanic.h"

#include "AknFepKeyCatcher.h"

#include "AknFepGlobalEnums.h"

#include "AknFepCaseManager.h"

#include "AknFepHashKeyManager.h"

#include "AknFepSharedDataInterface.h"

#include "AknFepInlineTextDecorator.h"

#include "AknFepUiManagerBase.h"

#include "AknFepUiManagerChinese.h"

#include "AknFepUiManagerWestern.h"

#include "AknFepPluginManager.h"

#include "AknFepUiIndicInputManager.h"

#include "AknFepUiIndicEnums.h"

#include <AknFepUIStylusPopupMenu.h>

#include "aknfepuispellinputpane.h"

#include <bautils.h>

#include <coeaui.h>                 //CCoeAppUi

#include <aknedsts.h>               //CAknEdwinState

#include <uikon.hrh>                //keys

#include <aknenv.h>                 //CAknEnv

#include <PtiEngine.h>              //CPtiEngine

#include <AknJapaneseReading.h>     //CAknJapaneseReading

#include <featmgr.h>                //FeatureManager

#include <e32base.h>                //CPeriodic

#include <PtiDefs.h>                //keys

#include <fepipext.h>               //MCoeFepSpecificExtensions

#include <aknsoundsystem.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <tagma.h>

#include <frmtview.h>

#include <aknedformaccessor.h>

#include <AknFep.rsg>

#include <avkon.mbg>

#include "aknconsts.h"

#include <aknfeppeninputenums.h>

#include <eikproc.h>                // User Dictionary

#include <eikapp.h>                 // User Dictionary

#include <StringLoader.h>

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#include <settingsinternalcrkeys.h>

#include <AknUtils.h>

#include <AknCustomCursorSupport.h>

#include <PtiKeyMappings.h>

#include <aknfeppeninputimeplugin.h>

#include <peninputcmd.h>

#include <AknSettingCache.h>

#include <aknextendedinputcapabilities.h>

#include <AvkonInternalCRKeys.h>

#include <hlplch.h>

#include <aknfepdocumentnavigation.h>

#include <eikcolib.h>

#include <akntoolbar.h>

#include <eikfrlbd.h>

#include <eikccpu.h>

#include <aknappui.h>

#include <apgwgnam.h>

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include "AknFepUiWordPopupContent.h"

#include "AknFepFnKeyManager.h"

#include <csxhelp/cp.hlp.hrh> 

#endif //RD_INTELLIGENT_TEXT_INPUT

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

#include "AknFepThaiSCTSelector.h"

//the follow 10 filse include for phrase creation

#include <bamdesca.h>

#include <eikspane.h> //CEikStatusPane 

#include <akntitle.h> //CAknTitlePane 

#include <akntoolbar.h> //CAknToolBar 

#include <aknappui.h>

#include "AknFep.hrh"

#include "aknfepuserdbdlg.h"

#include "aknfepzhuyinkeyhandler.h"

#include "AknFepZhuyinAnalyser.h"

#include "AknFepZhuyinAnalyserDb.h"

#include <aknnavi.h> 

#include <aknnavide.h> 

#include <eikedwin.h>

#include <aknCharMap.h>

const TInt KSelectItemSize(10);

_LIT(KAknFepResourceFileName, "z:\\resource\\fep\\aknfep.rsc");

#define text_to_field_mode_hash_key ';'

#define iAvkonAppUi ((CAknAppUi*)CEikonEnv::Static()->EikAppUi())

#define __SHIFT_KEY_LOOP

// EAknEditorNativeKeysNumberModeKeymap is used for example in MFNE editors.

#define EAknEditorNativeKeysNumberModeKeymap EAknEditorReservedInternalUseKeymap

// UID of user dictionary application

const TUid KUidUserDictApp = {0x101F8645};

const TText KAknFEPLineFeedSymbol = 0x21B2;

const TText KAknFEPMirroredLineFeedSymbol = 0x21B3;

const TText KAknFEPZeroKey = 0x30;

// inline text decoration potentially adds 2 directional markers for every "real" character. Buffer needs to be 3 x predictive engine bufsize

const TInt KMaxInlineEditSize( 3 * CAknFepManager::EMaximumFepWordLength );

// Maximum number of chunks to navigate throught attempting to get to the visual end of a selection.

// Since chunks are arranged only within a line, this should be more than the number of chunks likely in

// a single line of text

const TInt KMaxChunkWalkIterations(20);

// This command is is used for setting empty CBA.

const TInt KNullCommandId = 0;

_LIT_SECURE_ID(KPhoneSecureId, 0x100058b3);

#ifdef RD_HINDI_PHONETIC_INPUT

const TUint KQuestionMark = 0x003F;

#endif

// Ccpu key events. 

/*As part of build warnings commenting this perticular code it might require when touch is enabled.

const TKeyEvent KEditorCopyEvent = {3, 67, 161, 0};  // Ctrl + C

const TKeyEvent KEditorCutEvent  = {24, 88, 161, 0}; // Ctrl + X

*/

const TInt KTouchInputPreviewOn = 1;

const TInt KTouchInputPreviewOff = 0;

#ifdef  RD_SCALABLE_UI_V2

const TKeyEvent KAknCcpuCopyEvent = {EKeyF18, EEikCmdEditCopy, EModifierCtrl, 1};  // Copy event for AknCcpuSupport

const TKeyEvent KAknCcpuCutEvent  = {EKeyF18, EEikCmdEditCut, EModifierCtrl, 1};   // Cut event for AknCcpuSupport

const TInt KEditorMenuPermitedSend[KMaxMenuSize] = 

    {         

    EJapanFepCmdModeHiragana,

    EJapanFepCmdModeKatakana,

    EJapanFepCmdEditModeAlpha,

    EJapanFepCmdEditModeNumber,

    EJapanFepCmdModeFullWidth,

    EJapanFepCmdModeHalfWidth,

    EChinFepCmdModePinyin,

    EChinFepCmdModeZhuyin,

    EChinFepCmdModeStroke,

    EAknCmdT9PredictiveT9Off,

    EAknCmdMultitapPredictiveT9On,

    EJapanFepCmdMultitapPredictiveT9On,

    EChinFepCmdModeZhuyinFind,

    EChinFepCmdModeStrokeFind,

    EAknCmdEditModeAlpha,

    EAknCmdEditModeLatinText,

    EChinFepCmdModeLatinUpper,

    EChinFepCmdModeLatinLower,

    EAknCmdEditModeNumber,

    EChinFepCmdModeNumber,

    EAknCmdEditModeArabicIndicNumber,

    EAknCmdEditModeEasternArabicIndicNumber,

    };   

#endif // RD_SCALABLE_UI_V2 

// Number modes used by Arabic or Hindi.

enum TNonLatinNumberModes

    { 

    ENbrModeLatin,

    ENbrModeArabic = 1,

    ENbrModeIndic = 1

    };

// Number mode type

enum TNonLatinNumberModeType

    {

    ENbrModeTypeArabic,

    ENbrModeTypeIndic,

    ENbrModeTypeEasternArabic //for Urdu & Farsi languages

    };

// The passwd timeout is same as defined on CEikSecretEditor.

const TInt KSyncPasswdTimeout = 1000000;

#ifdef RD_SCALABLE_UI_V2

TUid AppUidFromWndGroupId(TInt aWndGrpId);

extern TUid GetCurAppUid();

extern TBool IsGlobalNotesApp(TUid& aUid);

TInt GetForegroundTaskAppWgId();

#endif

#ifdef RD_INTELLIGENT_TEXT_INPUT

const TInt KWordToFocusInCandidateList = 1;

#endif

LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

//

// Class TTextDirectionalInfo

//

/**

* The implementation inializes with well-defined "null" state

*/

CAknFepManager::TTextDirectionalInfo::TTextDirectionalInfo() : 

iDirectionalStatus(EUnknown), iBlockEnvironment(EUndefined)

    {}

void CAknFepManager::TTextDirectionalInfo::SetDirectionFromChunk( 

               const CTmTextLayout::TTmChunkDescription& aChunk )

    {

    if ( aChunk.iStart >= 0 ) // Condition for valid block. Does nothing otherwise

        iDirectionalStatus = aChunk.iRightToLeft ? ERightToLeft : ELeftToRight;

    }

void TFepLanguageTranslation::ReadFromResource(TResourceReader& aReader)

    {

    iName.Set(aReader.ReadTPtrC());

    iLanguageId = aReader.ReadInt16();

    iCommandId = aReader.ReadInt16();

    }

CAknFepManager::CAknFepManager(CCoeEnv& aConeEnvironment)

    :CCoeFep(aConeEnvironment),

    iAsyncResouceChanged(EActivePriorityDefault),

    iPreviousEditingState(EStateNone),

    iInputCapabilities(TCoeInputCapabilities::ENone),

    iModeBefore(ELatin),

    #ifdef RD_INTELLIGENT_TEXT_INPUT

    iKeyPressedDuringShift(EFalse),

#endif

    iCharWidth(EHalfWidthChar),

    iAsyncOwnSimulateKey(EActivePriorityDefault),

    iLongThai0Key(EFalse),

    iEditCharsPtr(0,0),

    iComposChrFlag(0),

    iIsUserdbdlgActive(0),

    iLongClearAfterCloseUI(EFalse),

    // phrase creation

    iPhraseCreation(0),

    iPinyinPhraseCreation(0),

    iEntryPhrase(0)

    {

    }

void CAknFepManager::ConstructL(const CCoeFepParameters& aFepParameters)

    {

    BaseConstructL(aFepParameters);

    iUiInterface = CAknFepUIInterface::NewL();

    iIndicator = iUiInterface->NewIndicatorL();

    iPreviousIndicator = CAknEnv::Static()->SwapEditingStateIndicator(iIndicator);

    // Set up resources

    TFileName resourceName(KAknFepResourceFileName);

    CCoeEnv* coeEnv = CCoeEnv::Static();

    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceName);

    iResId = coeEnv->AddResourceFileL(resourceName);

    // Save Japanese Feature support to a member variable

    iFeatureSupportedJapanese = FeatureManager::FeatureSupported(KFeatureIdJapanese);

    iUiLanguage = User::Language();

    // Shared Data

    iSharedDataInterface = CAknFepSharedDataInterface::NewL(this);

    TInt previUiLanguage = iSharedDataInterface->PluginUILanguage();

    if (iUiLanguage != previUiLanguage)

        {

        // if UI language has changed we need to set text input language according to UI language

        iSharedDataInterface->SetPluginUILanguage(iUiLanguage);

        iSharedDataInterface->SetInputTextLanguage(0);  // signals that it needs to be updated

        }

    if (!iSharedDataInterface->InputMode()) //not initialised yet - first time device is switched on

        {

        switch (iUiLanguage)

            {

            case ELangPrcChinese:

                iSharedDataInterface->SetInputMode(EPinyin);

                break;

            case ELangTaiwanChinese:

                iSharedDataInterface->SetInputMode(EZhuyin);

                break;

            case ELangHongKongChinese:

                iSharedDataInterface->SetInputMode(EStroke);

                iSharedDataInterface->SetCangJieMode(ECangJieNormal);

                break;

            case ELangJapanese:

                iSharedDataInterface->SetInputMode(EHiraganaKanji);

                break;

            case ELangKorean:

                iSharedDataInterface->SetInputMode(EHangul);

                break;

            case ELangHindi:

                iSharedDataInterface->SetInputMode(EHindi);

                break;

            default:

                iSharedDataInterface->SetInputMode(ELatin);

                break;

            }

        }

    iUiInterface->SetFepMenuObserver(this);

    TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

    // A process instantiating Fep may miss ECapabilityWriteDeviceData capability, 

    // which is needed for updating locale repository.

    // A workaround is to delay change up to a process that has the capability

    TSecurityInfo info;

    info.Set(RProcess());

    TBool hasCapability = info.iCaps.HasCapability(ECapabilityWriteDeviceData);

    if (!inputLanguage && hasCapability)

        {

        // set correct input language

        inputLanguage = SubstituteSublanguageId(iUiLanguage);

        // If Ptiengine is not initialize, initialize it

        if (!iPtiEngine)

            {

            iPtiEngine = CPtiEngine::NewL(ETrue);    

            }         

        // If still not found, default to english.

        if (!iPtiEngine->GetLanguage(inputLanguage))

            {

            inputLanguage = ELangEnglish;   

            }

        // Set the current input language

        iSharedDataInterface->SetInputTextLanguage(inputLanguage);

        // update numeric input

        if ( iUiLanguage == ELangArabic ) 

            {

            SetDefaultNumberMode( ENbrModeArabic, 

                                  ENbrModeTypeArabic );

            }            

        else if ( ( iUiLanguage == ELangUrdu  ) || 

                  ( iUiLanguage == ELangFarsi  ) )

            {

            SetDefaultNumberMode( ENbrModeArabic, 

                                  ENbrModeTypeEasternArabic );

            }

		else if ( TAknFepUiIndicInputManager::IsScriptDevanagari( iUiLanguage ) )

            {

            SetDefaultNumberMode( ENbrModeLatin, 

                                  ENbrModeTypeIndic );

            }

        else

            {           

            SetDefaultNumberMode( ENbrModeLatin, ENbrModeTypeArabic );

            }

        }

    iSctEditChars = HBufC::NewL( 10 );

#ifdef RD_INTELLIGENT_TEXT_INPUT

    // Predictive QWERTY (XT9) changes ---->

    	if(CCoeEnv::Static()->AppUi())

				iExactWordPopupContent = iUiInterface->CreateWordPopupContentL();

    // Predictive QWERTY (XT9) changes <----

#endif //RD_INTELLIGENT_TEXT_INPUT

    // If the following line is uncommented, the FEP is fully constructed

    // for all applications at application startup.

    // ConstructFullyL();

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

#ifdef RD_INTELLIGENT_TEXT_INPUT

    iFnKeyManager = CAknFepFnKeyManager::NewL( *this,iSharedDataInterface );

#endif

    TRAPD(result,iKeyCatcher = CAknFepKeyCatcher::NewL(*this));

    if(result == KErrNone)

        {

        iKeyCatcher->ActivateL();

        }

    // the follow 3 objects for phrase creation

    iZhuyinKeyHandler = CZhuyinKeyHandler::NewL();

    iZhuyinAnalyserDb = CZhuyinAnalyserDbFeed::NewL(EPinyinAnalyserTypeZhuyin);

    iZhuyinAnalyser = CAknFepZhuyinAnalyser::NewL(iZhuyinAnalyserDb);

    iAknFepThaiSCTSelector = CAknFepThaiSCTSelector::NewL();

    iHybridAplphaChangedToAlphanumeric = EFalse;

    iLastFocusedEditor = NULL;

    iFepAwareDialogParentEditor = NULL;

    }

void CAknFepManager::ConstructFullyL()

    {

    if (!iPtiEngine)

        {

        iPtiEngine = CPtiEngine::NewL(ETrue);    

        } 

    if ( !(iPtiEngine->GetLanguage(iSharedDataInterface->InputTextLanguage())) )

        {

        // If input language cenrep value is set to language unknown to PtiEngine,

        // try to reset based on UI-language. 

        TInt inputLang = SubstituteSublanguageId(iUiLanguage);

        // If still not found, default to english.

        if (!iPtiEngine->GetLanguage(inputLang))

            {

            inputLang = ELangEnglish;   

            }

        iSharedDataInterface->SetInputTextLanguage(inputLang);      

        }      

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

    if (iPtiEngine->GetLanguage(iSharedDataInterface->InputTextLanguageSecondary()) == NULL)

        {

        // If secondary input language is unknown to PtiEngine, set it to none

        iSharedDataInterface->SetInputTextLanguageSecondary(0);

        }

#endif //FF_DUAL_LANGUAGE_SUPPORT

#endif

    if(NULL == iKeyCatcher)

        {

        iKeyCatcher = CAknFepKeyCatcher::NewL(*this);    

        iKeyCatcher->ActivateL();

        }

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

    iPostEventCheck=CIdle::NewL(CActive::EPriorityStandard);

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

    CCoeEnv* coeEnv = CCoeEnv::Static();

    TInt inputLanguage = iSharedDataInterface->InputTextLanguage();

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

    TInt inputLanguageSecondary = iSharedDataInterface->InputTextLanguageSecondary();

#endif //FF_DUAL_LANGUAGE_SUPPORT

#endif

    SetWesternPredictive(iSharedDataInterface->PredictiveTextOn());

#ifndef RD_INTELLIGENT_TEXT_INPUT

    iIsAutoCompleteOn = iSharedDataInterface->PredictiveTextAutoCompleteOn(); // AutoCompletion disabled by Default 

#endif	//RD_INTELLIGENT_TEXT_INPUT

#ifdef RD_INTELLIGENT_TEXT_INPUT

    iIsAutoCompleteOn = iSharedDataInterface->PredictiveTextAutoCompleteOn(); // AutoCompletion disabled by Default 

    iTypingCorrectionLevel = iSharedDataInterface->PredictiveTextTypingCorrectionLevel();

    iIsNumberCandidateShown = iSharedDataInterface->PredictiveTextNumberCandidateShown();

    TInt primaryCandidateValue = iSharedDataInterface->PredictiveTextPrimaryCandidate();

    if( primaryCandidateValue == 0)

		iPrimaryCandidate = ETrue;

	else if(primaryCandidateValue == 1)

		iPrimaryCandidate = EFalse; 

#endif // RD_INTELLIGENT_TEXT_INPUT

    iJapanesePredictive = iSharedDataInterface->PredictiveTextJapaneseOn();

    iQwertyInputMode = iSharedDataInterface->QwertyInputMode();

    iMultiTapTimer = iSharedDataInterface->MultiTapTimer();

    iJapaneseQwertyFlags = iSharedDataInterface->JapaneseQwertyFlags();

#ifdef RD_INTELLIGENT_TEXT_INPUT

    if(!iFnKeyManager)

        {

        iFnKeyManager = CAknFepFnKeyManager::NewL( *this,iSharedDataInterface );

        }    

#endif

    iCaseMan = CAknFepCaseManager::NewL(*this);

    iLangMan = CAknFepLanguageManager::NewL(this, iCaseMan);

    iPtiEngine->ActivateLanguageL(inputLanguage);

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef FF_DUAL_LANGUAGE_SUPPORT

    iPtiEngine->SetSecondaryInputL(inputLanguageSecondary);

#endif //FF_DUAL_LANGUAGE_SUPPORT

#endif

    iLangMan->SetInputLanguageL(inputLanguage);

    SetInputLanguageCapabilities(inputLanguage);

    iCurrentFepUI = iLangMan->GetFepUI(ELatin, iCharWidth, IsPredictive(ELatin));

    iLastKeyPressedWasHashKey = EFalse;

    iDeviceSupportsRtlLanguage = DeviceSupportsRTLLanguageL();

    TResourceReader reader;

    // get character from resource to represent an 'enter' character

    coeEnv->CreateResourceReaderLC(reader, R_AVKON_SCT_SPACE_SYMBOL);

    iSpaceCharacterCode = reader.ReadUint16();