/*

* 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 CAknFepManager definition.

*

*/

#ifndef __AKN_FEP_MANAGER_H__

#define __AKN_FEP_MANAGER_H__

#include "AknFepGlobalEnums.h"          //TKeyPressLength

#include "AknFepManagerUIInterface.h"   //MAknFepManagerUIInterface

#include "AknFepLanguageManager.h"      //CAknFepLanguageManager

#include <gulicon.h>  

#include "aknfepuiinterface.h"

#include "aknfepuimenus.h"

#include <fepbase.h>                    //CCoeFep

#include <coeinput.h>                   //TCoeInputCapabilities

#include <fepitfr.h>                    //MFepInlineTextFormatRetriever

#include <aknedstsobs.h>                //MAknEdStateObserver

#include <uikon.hrh>                    //TAknEditorNumericKeymap

#include <aknEditStateIndicator.h>      //TAknEditingState

#include <frmtlay.h>

#include <biditext.h>

#include <PtiDefs.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#endif

#include <aknextendedinputcapabilities.h>

#ifdef RD_SCALABLE_UI_V2

#include <peninputclient.h>

#endif //#ifdef RD_SCALABLE_UI_V2

#include <AknNullService.h>             // CAknNullService

#include <AknServerApp.h>               // MAknServerAppExitObserver

#include <aknfeppensupportinterface.h>

#include "avkon.hrh"

#ifdef RD_HINDI_PHONETIC_INPUT	

#include <PtiIndicDefs.h>

#endif

#ifdef RD_INTELLIGENT_TEXT_INPUT

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

class MAknFepUiWordPopupContent;

#include "AknFepCandidatePopupCallback.h"

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

#endif //RD_INTELLIGENT_TEXT_INPUT

class CAknFepPluginManager;

class CAknFepKeyCatcherInterface;

class MAknFepManagerInterface;

class CAknFepIndicator;

class CAknEdwinState;

class CPeriodic;

class MAknEditingStateIndicator;

class CAknFepCaseManager;

class CAknFepHashKeyManager;

class CAknKeySoundSystem;

class CPtiEngine;

class CAknFepSharedDataInterface;

class CApaDocument; // User Dictionary

class CAknFepInlineTextDecorator;

class CTextView;

class MPeninputServerEventHandler;

class MAknFepDocumentNavigation;

class CAknFepUIInterface;

#ifdef RD_INTELLIGENT_TEXT_INPUT

class CAknFepFnKeyManager;

#endif

//phrase creation

class CZhuyinKeyHandler;

class CAknFepZhuyinAnalyser;

class CZhuyinAnalyserDbFeed;

//User DB view

class CAknFepUserdbDlg;

class CAknFepThaiSCTSelector;

class CAknNavigationDecorator;

// This could be moved inside FepManager class?

enum TWesternNaviEvent

    {

    ENullNaviEvent,

    ELeftNaviEvent,

    ERightNaviEvent,

    EBackspaceEvent,

    EUpNaviEvent,

    EDownNaviEvent

    };

enum TSpecialTextField

		{

 		/**

 		* Constraints

 		*/

    ESplAny,

    ESplMailAddr,

    ESplNumeric,

    ESplPhoneNumber,

    ESplUrl,

    ESplDecimal,

    /**

     * Modifiers

     */

    ESplPassword=0x10000,

    ESplUneditable=0x20000,

    ESplSensitive=0x40000,

    ESplNonPredictive=0x80000,

    ESPlInitialCapsWord=0x100000,

    ESplInitialCapsWordSentence=0x200000,

    ESplConstraintMask=0xFFFF

 		};    

const TInt KChrKeyMultitapTimeout = 1000000;

/**

 * Translates ET9Eng language codes into localised descriptors and command Id's

 */

class TFepLanguageTranslation

    {

    public:

        void ReadFromResource(TResourceReader& aReader);

    public:

        TPtrC           iName;

        TInt            iLanguageId;

        TInt            iCommandId;

    };

class CChrMultiTapTimer : public CTimer

    {

    public:

        static CChrMultiTapTimer* NewL(TCallBack aCallback);

        void After(TTimeIntervalMicroSeconds32 aInterval);

    private:

        CChrMultiTapTimer(TCallBack aCallback);

        void ConstructL();

        // from CActive

        virtual void RunL();

    private:

        TCallBack iCallback;

    };

/**

 * The CCoeFep derived class of AknFep

 * Controls mode in the Fep. Handles all interaction with the editor

 * Creates and owns the UI Manger, the Key Catcher and the edit state indicators

 */

class CAknFepManager :

    public CCoeFep,

    public MAknFepManagerUIInterface,

    public MFepInlineTextFormatRetriever,

    public MFepPointerEventHandlerDuringInlineEdit,

    public MAknFepUiInterfaceMenuObserver,

    public MAknServerAppExitObserver,   //embedding

    private MAknEdStateObserver,

#ifdef RD_SCALABLE_UI_V2  

    public CAknExtendedInputCapabilities::MAknEventObserver,

#endif

    private MFormCustomDraw

#ifdef RD_INTELLIGENT_TEXT_INPUT

    ,public MAknFepCandidatePopupCallback // Predictive QWERTY (XT9) changes

#endif //RD_INTELLIGENT_TEXT_INPUT

    {

private:

    class TTextDirectionalInfo

        {

        public:

            enum TTextDirectionalStatus

                {

                EUnknown,

                    ENotInDocument,

                    ENoDirectionalChunks,

                    ERightToLeft,

                    ELeftToRight

                };

            enum TDirectionalBlockEnvironment

                {

                EUndefined,

                    EInsideBlock,

                    EAtRightEndOfLine,

                    EAtLeftEndOfLine,

                    EAtRightEndOfBlockFacingOppositeDirectionalBlock,

                    EAtLeftEndOfBlockFacingOppositeDirectionalBlock,

                    EAtRightEndOfBlockFacingSameDirectionBlock,

                    EAtLeftEndOfBlockFacingSameDirectionBlock

                };

        public:

            // Constructor

            TTextDirectionalInfo();

            void SetDirectionFromChunk( const CTmTextLayout::TTmChunkDescription& aChunk);

        public:

            TTextDirectionalStatus iDirectionalStatus;

            TDirectionalBlockEnvironment iBlockEnvironment;

        };

public:

    /**

     * values for the flags required to maintain the internal

     * state of the Fep Manager during operation

     */

    enum

        {

        EFlagInsideMultitapInlineEditingTransaction     =0x00000001,

        EFlagLaunchEditMenu                             =0x00000002,

        EFlagLongShiftKeyPress                          =0x00000004,

        EFlagNoActionDuringShiftKeyPress                =0x00000008,

        EFlagShiftKeyDepressed                          =0x00000010,

        EFlagInsideInlineEditingTransaction             =0x00000020,

        EFlagPassNextKey                                =0x00000040,

        EFlagQwertyChrKeyDepressed                      =0x00000080,  // Not used. Qwerty mode is not supported.

        EFlagLineFeedCharacter                          =0x00000100,

        EFlagEditorFull                                 =0x00000200,

        EFlagNewSharedDataInputMode                     =0x00000400,

        EFlagNoActionDuringChrKeyPress                  =0x00000800,

        EFlagSupressAutoUpdateAtEditorStart             =0x00001000,

        EFlagNoMatches                                  =0x00002000,

        EFlagSuppressInputStateChange                   =0x00004000,

        EFlagCompoundWord                               =0x00008000,

        EFlagChangeInputMode                            =0x00010000,

        EFlagForegroundUIComponentVisible               =0x00020000,

        EFlagMenuPaneVisible                            =0x00040000,

        EFlagRemoveMatchesMenuItem                      =0x00080000,

        EFlagInlineEditInBackground                     =0x00100000,

        EFlagNewSharedDataInputLanguage                 =0x00200000,

        EFlagLastCharacterInEditor                      =0x00400000,

        EFlagSpaceCharacter                             =0x00800000,        // adding for japanese

        EFlagFullWidthSpaceCharacter                    =0x01000000,        // adding for japanese

        EFlagBidiCursorIsInitialized                    =0x02000000,

        EFlagCursorPointsRightToLeft                    =0x04000000,

        EFlagAtDirectionallyAmbiguousPoint              =0x08000000,

        EFlagCharacterAdded                             =0x10000000,

        EFlagNoInlineEditFormatting                     =0x20000000,  // Not really used yet!

        EFlagQwertyShiftMode                            =0x40000000,  // Not used. Qwerty mode is not supported.

        EFlagSupressAutoUpdate                          =0x80000000

        };

     enum

     	{

		EExtendedFlagShortPressHashKey                    =0x00000001,

     	EExtendedFlagNoModeChange                         =0x00000002,

     	EExtendedFlagShiftReleasedOnPopup                 =0x00000004,

     	EExtendedFlagOkKeyPressOnCandidatePopup           =0x00000008,

     	/* Flag to take care of graceful exit for FEP launched dialog when the underneath editor is closed */

        EExtendedFlagEdwinEditorDestroyed                 =0x00000010,

        /* Flag to set decide when to set multiple observer for FEP. Set this flag whenever a FEP aware dialog is launched */

        EExtendedFlagFepAwareDialogLaunched               =0x00000020,

        /* Flag to specify that pointer event type EDrag has happened */ 

        EExtendedFlagPointerEventTypeEDrag                =0x00000040

    	};		

    //public constants

    enum

        {

        ESingleCharacter                            =1,

        EMaximumFepWordLength                       =63

        };

private:

    /**

     * private constants

     */

    enum

        {

        EShiftKeyRepeatDelay                        =800000, // 0.8s

        EQueryBufferLength                          =63,

        EDefaultNumericCharMapResId                 =0,

        EDefaultSCTResourceId                       =-1,

        ENoCharacters                               =0,

        EAknFepUid                                  =0x100056de,

        EStarKeyUnicodeValue                        =0x2A,

        EHashKeyUnicodeValue                        =0x23,

        ELeftSoftkeyIndex                           =CAknFepUIInterface::ELeftSoftkeyIndex,

        ERightSoftkeyIndex                          =CAknFepUIInterface::ERightSoftkeyIndex,

        EMiddleSoftkeyIndex                         =CAknFepUIInterface::EMiddleSoftkeyIndex,

        EWordConcatenationTimeout                   =2000000, // 2.0s

        ELanguageArrayGranularity                   =20,

        EChrKeyRepeatDelay                          =1000000, // 1.0s

        EHalfQwertyChrKeyRepeatDelay                =600000   //0.6 secs from Default actions UI spec

        };

    enum TChineseFepCursorType

        {

        EActive,

        EPassive

        };

public:            

	enum

		{

		ECcpuStateNone       = 0,

		ECcpuStateStartCopy  = 0x01,

		ECcpuStateCopy       = 0x02,	

		ECcpuStateStartCut   = 0x04,

		ECcpuStateCut        = 0x08,

		ECcpuStateButton     = 0x10,

		ECcpuStatePosted               = 0x20,

		ECcpuStateHashDown             = 0x40,

		ECcpuStateSelectionEventPosted = 0x80,

		ECcpuStateEdwinInSelectionMode = 0x100,

		ECcpuStateIgnoreStarUp          = 0x200,

		ECcpuSupressEditMenuFromShiftUp = 0x400,		

		ECcpuStateCbaSymbol             = 0x800,

		ECcpuStateIgnoreNextFocusChange = 0x1000,

		ECcpuStataCommitPredictiveWord  = 0x2000,

		ECcpuStateIgnoreNextEdwinSyncEvent = 0x4000,

		ECcpuStateLosingFocus			   = 0x8000,	

		ECcpuStateUncommitWhenFocused = 0x10000,				

        ECcpuStateHashKeyDeleteDone = 0x20000,

        ECcpuStateSupressCursorMoveToEnd = 0x40000,

        ECcpuStateChangeToPredictionMode = 0x80000,

		ECcpuStateNewPredictiveWord = 0x100000,

		ECcpuStateShiftkeyWasPressedBeforeLosingFocus = 0x200000,

		ECcpuStateCbaShown = 0x400000

        };

	enum TShowSctMode 

	    {

	    EShowSctFirst=0, 

	    EShowPctFirst, 

	    EShowSmileyFirst 

	    };

private:

	 // These are needed to remember editor's ccpu state 

	 // for editing options submenu.

     enum

     	{

     	ECcpuStatusFlagCanCopy  = 0x01,

     	ECcpuStatusFlagCanCut   = 0x02,

     	ECcpuStatusFlagCanPaste = 0x04,     	

     	};

private:

    class TLanguageCapabilities

        {

        public:

            TInt iInputLanguageCode;        // Symbian language code.

            TBool iLocalInputLanguageInUse;

            TBool iArabicIndicDigitsAllowed;

            TBool iEasternArabicIndicDigitsAllowed;

            TBool iIndicDigitsAllowed;	

            TDigitType iLocalDigitType;

            TDigitType iNumericEditorDigitType;

            TBool iSupportsCase;

            TBool iSupportsWesternPredictive;

#ifdef RD_INTELLIGENT_TEXT_INPUT

            // Predictive QWERTY changes ---->

            TBool iSupportsWesternQwertyPredictive; // predicitve QWERTY

            // Predictive QWERTY changes <----

#endif //RD_INTELLIGENT_TEXT_INPUT

            TBool iRightToLeftLanguage;

#ifdef RD_INTELLIGENT_TEXT_INPUT

#ifdef __HALF_QWERTY_KEYPAD            

            TBool iSupportsWesternHalfQwertyPredictive;

#endif //__HALF_QWERTY_KEYPAD            

#endif //RD_INTELLIGENT_TEXT_INPUT 

        };

public:

    /**

     * C++ Constructor

     */

    CAknFepManager(CCoeEnv& aConeEnvironment);

    /**

     *  Second phase construction

     */

    void ConstructL(const CCoeFepParameters& aFepParameters);

    /**

     * destructor

     */

    virtual ~CAknFepManager();

public: //from MAknFepManagerUIInterface

#ifdef RD_INTELLIGENT_TEXT_INPUT

     /**

     Returns the keyboard layout

     */

     TPtiKeyboardType KeyboardLayout() const;

     /**

     Returns the current keyboard layout in use.

     */	 

     CAknFepFnKeyManager::TFnKeyState FnKeyState();

     void SetFnKeyState(CAknFepFnKeyManager::TFnKeyState aState);

    /**

     * Returns the resource ID of the numeric editor in use

     */

    TInt GetNumericSCTResID();

#ifdef __REVERSE_FN_KEY_SUPPORTED

     /**

    Returns if the input is in reverse Fn key input mode.

    */

    virtual TBool IsReverseFnkeyInput();

    void SetReverseFnkeyInputMode(TBool iIsOn);

    /**

     * Returns true if the aChar is allowed in the numeric editor

     */

    TBool IsValidCharInNumericEditorL( TChar aChar ) const;

    /**

     * Filter the char for Fn reverse mode in case of

     * numeric editor. This function should call

     * in case of numeric editor reverse mapping.

     */

    TBool IsValidCharForNumericInFnReverseL(TInt aKey, TPtiTextCase aCase) ;

#endif //__REVERSE_FN_KEY_SUPPORTED

    virtual void AddOneSpaceOrMoveCursorL();

#endif

	virtual TBool IsAllowedKeymappingForNumberMode(TChar aChar) const;

	/**

     * closes the UI

     * commits any character in multitap

     */

    virtual TBool TryCloseUiL();

    /**

     * Used by the UI manager to inform the Fep Manager that the UI has activated.

     */

    virtual void SendUIActivatedNotification();

    /**

     * Used by the UI manager to inform the Fep Manger that the UI has not activated.

     */

    void SendUIDeActivatedNotification();

    /**

     * Plays sound

     */

    virtual void PlaySound(TAvkonSystemSID aSound) const;

    /**

     * Set current long clear key press

     */     

    virtual void SetLongClearAfterCloseUI(TBool aLongClear);

	/**

	 * Align the Logical and Visual cursor positions.

	 *

     * @since 3.2

     * @param aType Cursor type.

     * @param aToLeft ETrue if the position to the left is to be found,

     *			 	  EFalse if the position to the right is to be found.

     * @return None

	 */

	void AlignLogicalAndVisualCursorL( TTmDocPosSpec::TType aType, TBool aToLeft );

	/**

	 * This method removes the Repha character. The function goes to the 

	 * start of the syllable, checks if repha character is present and 

	 * removes it.

	 *

	 * @since 3.2

	 * @param None.

	 * @return None.

	 */							

	void RemoveRephaCharacterL();

	/**

	 * Checks if the Repha character has been attached to the syllable

	 *

	 * @since 3.2

	 * @param None.

	 * @return ETrue if present else EFalse.

	 */	

	TBool IsRephaPresent();

	/**

	 * Retrieve the Previous to previous character during multitapping.

	 *

	 * @since 3.2

	 * @param aContextSensitive EFalse is the default parameter.

	 *						    ETrue is used for requesting the function

	 *						    to check for extraction of the character

	 *						    two positions before the seleted text.

	 *

	 * @return The previous to previous character if any.

	 */

	TText PreviousToPreviousChar( TBool aContextSensitive = EFalse );

	 /**

	 * This method is called for removing the Rakar character. The function 

	 * checks if Rakar (Virama+Ra)  is present.

	 *

	 * @since 3.2

	 * @param None.

	 * @return None.

	 */

	void RemoveRakarCharacterL();

    /**

	 * This method is called for removing the N characters from the 

	 * specified position. If the text to be removed is not yet

	 * committed, it is updated with NULL descriptor and committed.

	 *

	 * @since 5.0

	 * @param TInt aPos position to start searching from. By default