/*

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

*

*/

#ifndef __AKN_FEP_MANAGER_UI_INTERFACE_H__

#define __AKN_FEP_MANAGER_UI_INTERFACE_H__

// INCLUDES

#include <e32std.h>

#include <avkon.hrh>

#include <frmtlay.h>        // TCursorSelection

#include <aknextendedinputcapabilities.h>

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <PtiDefs.h>

#endif

#include "AknFepGlobalEnums.h"

#include "AknFepUiIndicEnums.h"

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include "AknFepFnKeyManager.h"

#endif

// CLASS DECLARATION

class CPtiEngine;

class CAknFepUIInterface;

class CAknFepPluginManager;

// the follow 2 class for phrase creation 

class MZhuyinKeyHandler;

class CAknFepZhuyinAnalyser;

/**

  * This interface describes the FEP Manager functionality that is required by western 

  * Input States only. It could potentially be conditionally compiled out if western 

  * predictive text is not required in a product

  */

class MAknFepManagerUIInterfaceWestern

    {

public:

    /*

     *flags, all held in the FEP Manager

     */

    virtual TBool IsFlagSet(TInt aFlag) const = 0;

    virtual void SetFlag(TInt aFlag) = 0;

    virtual void ClearFlag(TInt aFlag) = 0;

	virtual void SetCcpuFlag(TInt aFlag) = 0;  

	virtual void ClearCcpuFlag(TInt aFlag) = 0;	  

    /*

     * Update the current inline edit

     * @param aUncommitedTextChange, the change to the length of the inline edit

     * i.e. 1 is a character added, 0 is no change, -1 is a character deleted

     */

    virtual void UpdateInlineEditL(const TDesC& aText, TInt aUncommitedTextChange) = 0;

    /*

     * Starts an inline edit

     */ 

    virtual void StartInlineEditL() = 0;

    /*

     * Starts an inline edit with a text string to uncommit

     */ 

    virtual void StartInlineEditL(const TDesC& aText) = 0;

    /*

    */

    virtual void StartInlineEditL(TCursorSelection aCursorSelection, 

                                  const TDesC& aInitialInlineText, 

                                  TInt aPositionOfInsertionPointInInlineText, 

                                  TBool aCursorVisibility) = 0;

    /*

     * Closes the UI backspace event have completely deleted a word

     */ 

    virtual TBool CloseUiIfWordDeletedL() = 0;

    /*

     * gets the text to uncommit in the engine when moving onto a word 

     *

     * @param aText the descriptor to fill with the text that should be uncommitted

     * @param aCode the keycode, must be backspace or left or right arrow

     * @param aComsumeKey ETrue if the key should be consumed

     * @return True if we have successfully found text which can be uncommited

     */     

    virtual TBool TryGetTextToUncommitL(TDes& aText, TInt aCode, TBool& aComsumeKey) = 0;

    /*

     * Update the CBA with a new resource

     */ 

    virtual void UpdateCbaL(TInt aResourceId) = 0;

    /*

     * Remove the character that is used to show to the user that the 

     * predictive text engine cannot match a word to the keys entered 

     * @return ETrue if the No Matches Indicator has been removed, EFalse

     * if it was not there.

     */ 

    virtual TBool TryRemoveNoMatchesIndicatorL() = 0;

    /*

     * @return ETrue if the new word length is one character longer than 

     * the current uncommited text

     */

    virtual TBool IsMoreGoodWordsComing(TInt aNewWordLength) const = 0;

    //the following 8 functions for creation   

    /**

     * Set the state to Pinyin phrase creation

     */

    virtual void PinyinPhraseCreation(TBool aPinyinPhraseCreation) = 0;

    /**

     * Is the state is in pinyin phrase creation

     *

     * @return if not enabled, return EFalse

     */

    virtual TBool IsPinyinPhraseCreation() const = 0;

    /**

     * Set the state to phrase creation

     */

    virtual void PhraseCreation(TBool aPhraseCreation) = 0;

    /**

     * Is the state is in phrase creation

     *

     * @return if not enabled, return EFalse

     */

    virtual TBool IsPhraseCreation() const = 0;

    /**

     * Set the state to input phrase

     */

    virtual void EntryPhrase(TBool aEntryPhrase) = 0;

    /**

     * Is the state is in input phrase

     *

     * @return if not enabled, return EFalse

     */

    virtual TBool IsEntryPhrase() const = 0;

    /**

     * Set the state to enable star key

     */

    virtual void EnableKeyStar(TBool aEnable) = 0;

    /**

     * Is the state is enable star key

     *

     * @return if not enabled, return EFalse

     */

    virtual TBool IsEnableKeyStar() const = 0;

#ifndef RD_INTELLIGENT_TEXT_INPUT

    /*

     * @return ETrue if inputmode is word completion and new word length is not equal to 

     * the current inputsequence length

     */

	virtual TBool IsMoreGoodAutoCompleteWordsComing(TInt aInputMode, TInt aPreviousWordLengh, 

	                                                TInt aNewWordLength) const =0;

#endif	// RD_INTELLIGENT_TEXT_INPUT

    /*

     * When starting a new word, checks the adjacent editor positions for 

     * valid inline editing characters. If these are present, we are starting a

     * compound word and the flag EFlagCompoundWord is set

     */

    virtual void TryStartCompoundWord() = 0;

    /*

     * Calculates the span of the compound word that is made up of the 

     * current uncommitted text and the adjacent word. 

     * Adds this word to the User Database

     */

    virtual void AddCompoundWordToUdbL() = 0;

    /**

 	*  Sets delayed commit on (predicitve word will be commited in 

 	*  next call to TryCloseUiL. This is needed because of Japanese ReadingTextL).

 	*

 	* @since 3.1

 	*/ 

    virtual void SetDelayedCommit() = 0;   

    /**

    * Returns a boolean value indicating whether the curesor is at the end of a word.

    */  

    virtual TBool IsCursorAtEndOfWord() = 0;       

    };

class MAknFepManagerUIInterface : public MAknFepManagerUIInterfaceWestern

    {

public:

#ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__

#ifdef RD_INTELLIGENT_TEXT_INPUT

    virtual TBool KeyMapsDifferentCharacterWithFn( TPtiKey aKey ) const = 0;

#endif

#endif

		/**

		* Check western predictive mode.

		* @param aMode input mode.

		* @return ETrue if western predictive mode.

		*/

		virtual TBool WesternPredictive(TInt aMode = 0) const=0;

		 /**

	     * Check Qwerty keypad

	     *

	     * @since 3.0

	     * @return ETrue is Qwerty

	     */

	    virtual TBool IsQwerty() const=0;

#ifdef RD_INTELLIGENT_TEXT_INPUT

    /**

     * Launches the compact match candidate list which follows the inline editor.

     * @param   aFocusedIndex   The index of the word focused by default. 

     *                          If KErrNotFound is given, the currently active

     *                          word will be focused.

     */

    virtual void LaunchCandidatePopupListL( TInt aFocusedIndex = KErrNotFound )=0;

    /**

    Returns the Fn key state

    */

    virtual CAknFepFnKeyManager::TFnKeyState FnKeyState() = 0;

    virtual void SetFnKeyState(CAknFepFnKeyManager::TFnKeyState aState) = 0;

    /**

    Returns the current keyboard layout in use.

    */

    virtual TPtiKeyboardType KeyboardLayout() const = 0;

#ifdef __REVERSE_FN_KEY_SUPPORTED

    /**

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

    */

    virtual TBool IsReverseFnkeyInput() = 0;

    /**

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

     */

    virtual TBool IsValidCharInNumericEditorL( TChar aChar ) const = 0;

    /**

     * Filter the char for Fn reverse mode in case of

     * numeric editor. This function should call

     * in case of numeric editor reverse mapping.

     */

    virtual TBool IsValidCharForNumericInFnReverseL(TInt aKey, TPtiTextCase aCase)=0;

#endif //__REVERSE_FN_KEY_SUPPORTED

    virtual void AddOneSpaceOrMoveCursorL() = 0;

#endif

    virtual TBool IsHybridAplhaEditor() const = 0 ;

    virtual TBool IsHybridAlphaModeChangedtoAplhanumeric() const = 0;

	/**

	* Tells if the current editor is phone number editor

	* @return ETrue if the current editor is phone number editor

	*/

	virtual TBool IsPhoneNumberEditor() const = 0;

    /**

     * A request to close the UI. If the UI was not active (initial state)

     * multitap characters are commited by calling ExpireMultitapTimer()

     * on the ptiengine.

     * @return ETrue if the UI was active, EFalse otherwise

     */

    virtual TBool TryCloseUiL() = 0;

    /**

     * A request to send a char to the editing window

     */

    virtual void NewCharacterL(const TDesC& aChar) = 0;

    /**

     * A request to send text to the editing window

     */

    virtual void NewTextL(const TDesC& aChar) = 0;

    /**

      * A request to commit the current char

      */

    virtual void CommitInlineEditL() = 0;

    /**

     * Commits given string in the editing window. This function checks that

     * the editor has enough space to insert given string. If it not,

     * given string is cut, then it is committed.

     */

    virtual void CommitInlineEditL(const TDesC& aText, TInt aUncommitedTextChange) = 0;

    /**

      * A request to cancel inline input to wditing window.

      */

    virtual void CancelInlineEdit() =0;

    /** 

      * Called by Fep Manager when editing window draws inline input characters.

      */

    virtual void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine,TInt& aHeight,

                                       TInt& aAscent,TInt aDocumentOffset) = 0;

    /** 

      * Called by Fep Manager when Chinese UI ask cursor baseline position.

      */

    virtual void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine,

                                       TInt& aHeight,TInt& aAscent) = 0;

    /**

     * A notification to the Fep Manager that the UI has been activated..

     * Should always be called by an Initial State Object when initiating 

     * a change to an Entry State

     */

    virtual void SendUIActivatedNotification() = 0;

    /**

     * A notification to the Fep Manager that the UI has not been activated.

     */

    virtual void SendUIDeActivatedNotification() = 0;

    /**

     * calulates if an SCT can be launched in the current editor at the present

     * cursor position

     * @return ETrue if an SCT can be launched, EFalse if not

     */

    virtual TBool IsAbleToLaunchSCT() const = 0;

    /**

     * Launch the Special Character Table  

     */

    virtual void LaunchSpecialCharacterTableL(TInt aResourceId=0, 

                                              TBool aLaunchedByTouchWin=EFalse, 

                                              TBool aSmileyFirst=EFalse) = 0;

    /**

     * Play sound

     */

    virtual void PlaySound(TAvkonSystemSID aSound) const = 0;

    /**

     * get uncommitted text

     */

    virtual TCursorSelection UncommittedText() const = 0;

	/**

     * Gets the previous character depnding on wheather language is 

     * contxet sensitve or not

     * since 3.2: aContextSensitive not in use, since no real meaning found.

     */

    virtual TText PreviousChar(	TBool aContextSensitive = EFalse ) = 0;

    /**

     * Returns the next character to the current cursor position

     */

    virtual TText NextChar() = 0;

    virtual TBool IsZWSCharacterPresent( TBool aLigaturePresent = EFalse ) = 0;

    /**

     * Removes previous character to the current cursor position

     */

    virtual void RemovePreviousCharacterL() = 0;

    /**

     * Removes Zero Width Space character from the inputted text.

     */

    virtual void RemoveZWSCharacterL(TBool aIsViramaInputted, 

                                     TBool aIsInMultitappingHalant = EFalse,

                                     TBool aIsCharModifier = EFalse, 

                                     TBool aIsLigaturePresent = EFalse) = 0;

    /**

     * Adds text to the editor and commits the text.

     */

    virtual void NewCharacterSequenceL(const TDesC& aText, TIndicInputResponse aResponse) = 0;

    virtual TDigitType LocalDigit() = 0;

    virtual TWidthChar CharacterWidth() const = 0;

    virtual void SetInlineEditingCursorVisibilityL(TBool aCursorVisibility) = 0;

    virtual CPtiEngine* PtiEngine() const = 0;

    /**

     * checks that the editor the editor has free space to add another character

     * An editor of unlimited length will return its maximum size as zero

     */

    virtual TBool EditorHasFreeSpace( TInt aNumberOfCharacter = 0 ) const = 0;

    virtual void RedecorateAfterDeletionL( const TDesC& aTextThatWasDeleted ) = 0;

    /**

     * 

     *

     * @param aKeyCode the value of the key to simulate

     */

    virtual void SimulateKeyEventL(TUint aKeyCode, TBool aActiveObj=EFalse) = 0;

    /**

     * Queries supportting of ScrollLatinPredictive feature

     *

     * @since 2.6

     * @return ETrue if ScrollLatinPredictive was supported

     */

    virtual TBool IsAbleScrollLatinPredictive() const = 0;

    virtual TBool IsOnlyNumericPermitted() const = 0;

    virtual TInt EditorNumericKeymap() const = 0;

    /**

     * Queries supportting of SecretText

     *

     * @since 2.6

     * @return ETrue if SecretText was supported

     */

    virtual TBool IsSupportsSecretText() const = 0;

	/**

	* Returns current input mode.

	*

	* @since 3.0

	* @return Integer value indicating current editor input mode.

    */

    virtual TInt InputMode() const = 0;

	/**

	* Returns current CangJie input mode.

	*

	* @since 3.0

	* @return Integer value indicating current CangJie input mode.

    */    

    virtual TInt CangJieMode() const = 0;

 	/**

    * Returns boolean value indicating whether edit submenu functionality is in use.    

    *  

    * @since 3.1

    * @return  ETrue if edit submenu functionality is in use.

    *          EFalse otherwise.

    */        

    virtual TBool EditSubmenuInUse() const = 0;   

    /**

     * Launches the mode selection menu

     *

     * @since 3.1

     */

    virtual void LaunchSelectModeMenuL() = 0;                  

    /**

     * @since 3.2

     */

    virtual void SetCursorSelectionL(const TCursorSelection& aCurSel, TBool aSyncCursor) = 0;    

   /**                

    * Returns the status of arabic-indic digit mode setting.

    *

    * @since 3.0

    */

    virtual TBool ArabicIndicDigitsInUse() const = 0;        

    virtual TBool EasternArabicIndicDigitsInUse() const = 0;

#ifndef RD_INTELLIGENT_TEXT_INPUT

   /**                

    * Returns the status of auto word completion in the editor.

    *

    * @since 5.0

    */

    virtual TBool IsAutoCompleteOn() const = 0;

   /**                

    * Removes the suggested completion part

    *

    * @since 5.0

    */

    virtual void RemoveSuggestedCompletionL() = 0;

#endif	// RD_INTELLIGENT_TEXT_INPUT

    /**

     * Set current long clear key press

     *

     * @since 3.2

     */    

    virtual void SetLongClearAfterCloseUI(TBool aLongClear) = 0;

	/**

	 * 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

	 */

	virtual void AlignLogicalAndVisualCursorL( TTmDocPosSpec::TType aType, 

											TBool aToLeft ) = 0;

	/**

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

	 * goes to the start of the consonant or ligature, checks if repha 

	 * character is present.

	 *

	 * @since 3.2

	 * @param None.

	 * @return None.

	 */							

	virtual void RemoveRephaCharacterL() = 0;

	/**

	 * Checks if the Repha character has been attached to the consonant or 

	 * ligature.

	 *