/*

* Copyright (c) 1997-1999 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:

*

*/

#if !defined(__EIKEDWIN_H__)

#define __EIKEDWIN_H__

#include <s32std.h>

#include <gdi.h>

#include <txtetext.h>

#include <medobsrv.h>

#include <gulutil.h>

#include <fepbase.h>

#include <frmvis.h>

#include <frmtview.h>

#include <uikon.hrh>

#include <eikon.hrh>

#include <eikbctrl.h>

#include <eikedwob.h>

#include <eiksbfrm.h>

#include <eikccpu.h>

#include <eiklay.h>

#include <lafmain.h>

#include <AknPictographDrawerInterface.h>

#include <babitflags.h>

#include <centralrepository.h>          // class CCenRepNotifyHandler;

#include <cenrepnotifyhandler.h>        // class CRepository;

class CGlobalText;

class CParaFormatLayer;

class CCharFormatLayer;

class MLayDoc;

class CEikEdwinFepSupport;

class CLafEdwinCustomDrawBase;

class CClipboard;

class CAknEdwinFormAccessor;

class CAknEdwinState;

class CAknInputPolicyManager;

class CFormCursorModifier;

class CTextView;

class MAknsControlContext;

class CAknEdwinDrawingModifier;

class CAknEdwinFormExtendedInterfaceProvider;

class CAknPhoneNumberInlineTextSource;

class CAknNoMatchesIndicatorInlineTextSource;

class CAknInlineTextSource;

class CAknPictographInterface;

class CAknExtendedInputCapabilities;

class CAknPointerEventSuppressor;

class CSmileyManager;

class CSmileyCustomWrap;

class CAknEdwinPhysicsHandler;

class CEdwinAsyncFormat;

class MAknsSkinInstance;

// Forward declaration of now removed (Series 60 2.0) custom drawer class for CEikEdwin

class CEikAvkonCustomDraw;

// Forward declaration of now removed (Series 60 2.0) custom drawer class for CEikEdwin

class CEikAvkonCustomDraw;

// For construction of Rich Text - based custom formatters

class CRichText;

class CAknPhysics;

enum TReplaceOption

	{

	ENoReplace,

	EReplaceOnce,

	EReplaceAll,

	EReplaceSkip

	};

/**

 * This describes the features of a

 * search-and-replace operation on a CEikEdwin.

 * 

 * See CEikEdwin::ReplaceL().

 */

struct SEdwinFindModel

	{

	/** Flags for the search (see CEikEdwin::TFindFlags) */

	TInt iFlags; // TEdwinFindFlags

	/** Text to search for. */

	TBuf<EEikEdwinFindStringMaxLen> iText;

	/** Text to replace it with. */

	TBuf<EEikEdwinFindStringMaxLen> iReplaceText;

	/** Replace options. */

	TReplaceOption iReplaceOption;

	};

/**

 * Styles for highlighting. See SetHighlightStyleL().

 */

enum TAknsHighlightStyle

    {

    /** Normal highlighting. */

    EEikEdwinHighlightNormal = 0,

    /** Link highlighting. */

    EEikEdwinHighlightLink

    };

// inline utility to handle RGB values (set / unset)      

class SAknRgb

    {

// data (private)    

    TRgb iValue;

    TBool iIsSet;

public: // utilities   

    SAknRgb():iIsSet(EFalse){}

    TRgb Value(){return iValue;}

    SAknRgb& operator=(TRgb aRgb)

        {

        iValue = aRgb;

        iIsSet = ETrue;

        return *this;

        }

    TBool IsSet(){return iIsSet;}

    };    

/** 

 * Base class for controls that display and allow manipulation of text.

 *

 * The properties of a particular Edwin object can be set using bitwise flags, 

 * which are defined in member enums (see @c TFlags for example).

 *

 * Edwins support Front End Processors, and so are a highly effective way of 

 * getting textual data from the user. The text currently being composed by the

 * user is called the composition text.

 */

class CEikEdwin : public CEikBorderedControl, 

                  public MEikScrollBarObserver, 

                  public CTextView::MObserver, 

                  public MEditObserver, 

                  public MEikCcpuEditor

	{

private:

    class CUndoBuffer;

    NONSHARABLE_CLASS(CEikEdwinExtension) : public CBase, MCenRepNotifyHandlerCallback

        {

    public:

        /**

         * Allocates and constructs a CEikEdwinExtension.

         *

         * @param aEdwin Pointer to the CEikEdwin creating the extension.

         * @return A newly constructed edwin extension.

         */

		static CEikEdwinExtension* NewL(CEikEdwin* aEdwin);

		/**

		 * Destructor.

		 */

		~CEikEdwinExtension();

		/**

		 * Gets the form accessor.

		 *

		 * @return The form accessor.

		 */

		IMPORT_C CAknEdwinFormAccessor* FormAccessor() const;

		/**

		 * Sets the form accessor.

		 *

		 * @param aFormAccessor The form accessor.

		 */

		IMPORT_C void SetFormAccessor(CAknEdwinFormAccessor* aFormAccessor);

		/**

		 * Sets the CIdle object to update scroll bar.

		 *

		 * @param The CIdle object to perform scroll bar updating.

		 */

		IMPORT_C void SetScrollBarSetter(CIdle* aScrollBarSetter);

		/**

		 * Gets the CIdle object which updates scroll bar.

		 *

		 * @return The CIdle object used to perform scroll bar updating.

		 */

		IMPORT_C CIdle* ScrollBarSetter();

		/**

		 * Gets the custom wrapper.

		 *

		 * @return The custom wrapper.

		 */

		IMPORT_C const TAvkonEditorCustomWrap& TextWrapper();

		// the following two methods are deprecated

        IMPORT_C CFormCursorModifier* FormCursorModifier() const;

        /**

        * Store a locally stored (but externally set) Skins background control context.

        *

        * @param aBackgroundControlContext   Control context to store. Not owned. Can be NULL.

        */

        void SetSkinBackgroundControlContext( MAknsControlContext* aBackgroundControlContext );

        /**

        * Access to locally stored Skins background control context.

        * 

        * @return Pointer to locally stored control context

        */

        MAknsControlContext* SkinBackgroundControlContext() const;

        /**

        * This returns a flag that records whether the background context has ever been 

        * set by API.

        *

        * @return   EFalse iff control context has never been set.

        */

        TBool SkinBackgroundControlContextHasBeenSet() const;

        /**

        * Stores the alignment value.

        *

        * @param aAlignment   Editor alignment to be stored.

        */

        void SetAlignment(TInt aAlignment);

        /**

        * Returns the stored alignment value.

        *

        * @return Value of the current editor alignment.

        */

        TInt CurrentAlignment() const;

        /**

        * Sets pictograph animation callback.

        */

        void SetPictoCallBack( TCallBack& aCallBack );

        /**

        * Sets pictograph animation callback.

        */

        const TCallBack& PictoCallBack() const;

        /**

        * Creates the CAknFormExtendedInterfaceProvider object if it does not exist.

        */

        void CreateFormExtendedInterfaceProviderIfNeededL();

        /**

        * Access to Form's extended interface provider.

        */

        CAknEdwinFormExtendedInterfaceProvider* FormExtendedInferfaceProvider() const;

        /**

        * Create a custom formatter for pure phone number content.

        *

        * Calls CreateFormExtendedInterfaceProviderIfNeededL to ensure that there is an

        * ExtendedInterfaceProvider object built.

        *

        * @param    aTextLayout     Reference to the CTextLayout object used for this editor.

        *           aText           CPlainText object reference for the text used in the editor.

        */

        void CreatePurePhoneNumberFormatterL( CTextLayout& aTextLayout, const CPlainText& aText);

        /**

        * Create a custom formatter for pure phone number content.

        *

        * Calls CreateFormExtendedInterfaceProviderIfNeededL to ensure that there is an

        * ExtendedInterfaceProvider object built.

        *

        * @param    aTextLayout     Reference to the CTextLayout object used for this editor

        */

        void CreateNoMatchesIndicatorFormatterL( CTextLayout& aTextLayout );

        /**

        * Create a custom formatter for rich text editor with general content. Phone numbers are

        * recognized using an internal parser and formatted with the number grouping engine

        *

        * Calls CreateFormExtendedInterfaceProviderIfNeededL to ensure that there is an

        * ExtendedInterfaceProvider object built.

        *

        * @param    aTextLayout     Reference to the CTextLayout object used for this editor

        */

        void CreateRichTextPhoneNumberFormatterL( CTextLayout& aTextLayout, const CRichText& aText );

        /**

        * This allows the caller to access the single inline text interface that will be seen

        * by Tagma.  All installed inline text source classes are held behind this single interface

        * 

        * @return   pointer to the inline text source object that will be provided to Tagma

        *           Null is returned if none is installed.

        */

        CAknInlineTextSource* InlineTextSource() const;

        /**

        * Returns pointer to pictograph interface.

        *

        * @return Pointer to pictograph interface. The value can be NULL if pictographs are not supported.

        */

        CAknPictographInterface* PictographInterface() const;

        /**

        * Used for suppressing all editor's background drawing.

        */

        void SetSuppressBackgroundDrawing( TBool aSuppress );

        /**

        * Tests if the background drawing is suppressed.

        */

        TBool IsBackgroundDrawingSuppressed() const;

        /**

        * Returns the value of ClearDirection

        *

        * @return value of current ClearDirection

        */

        TInt ClearDirection() const;

        /**

         * Enables kinetic scrolling.

         */

        void EnableKineticScrollingL( CAknPhysics* aPhysics = NULL );

        /**

         * Enables physics.

         */

        void EnablePhysicsL( CAknPhysics* aPhysics = NULL );

        /**

         * Initializes physics.

         */

        void InitPhysicsL();

    public: // from MCenRepNotifyHandlerCallback

        void HandleNotifyInt(TUint32 aId, TInt aNewValue);

    private:

        CEikEdwinExtension();

        void ConstructL(CEikEdwin* aEdwin);

    private:

        enum TFlagIndices

            {

            ESkinBackgroundControlContextHasBeenSetIndex = 0,

            ESuppressBackgroundDrawing,

            EKineticScrollingEnabled

            };

        class TAknEdwinPictographDrawer : public MAknPictographAnimatorCallBack

            {

            private: // From MAknPictographAnimatorCallBack

                void DrawPictographArea();

            };        

	private:

		CIdle* iSetScrollBar;

		TAvkonEditorCustomWrap iTextWrapper;

		CAknEdwinFormAccessor* iFormAccessor;

        CFormCursorModifier* iFormCursorModifier;

        MAknsControlContext* iSkinBackgroundControlContext;

        TBitFlags iFlags;

        TInt iAlignment;

        TCallBack iPictoCallBack;       

        CAknEdwinFormExtendedInterfaceProvider* iFormExtendedInterfaceProvider; // Owned

        CAknInlineTextSource* iPhoneNumberFormatter;                 // Not owned

        CAknNoMatchesIndicatorInlineTextSource* iNoMatchesIndicatorFormatter;   // Not owned

        TAknEdwinPictographDrawer iPictographDrawer;

        CAknPictographInterface* iPictographInterface;

        // For clear direction.

        CRepository* iCenRep;                           // Owned

        CCenRepNotifyHandler* iCenRepNotifyHandler;     // Owned

        TInt iClearDirection;                           // Value of ClearDirection

     public:

        TInt iSkinIdForText;

        TAknsHighlightStyle iSkinHighlightStyle;

        SAknRgb iEditorBackgroundColor;

        TInt iUpperFullFormattingLength;

        CAknExtendedInputCapabilities* iExtendedInputCapabilities;

        TRect iTextLinesRect;

        TRect iScrollRect;

        TInt iTempCursorPos;

        TInt iTempAnchorPos;

        TInt iTempSelect;

        CAknPointerEventSuppressor* iPtSuppressor;

        TBool iDragging;

        TInt iRecordCursor;

        TBool iRecordScroll;

        /**

        * @c iDestroyedPtr is used for the object destruction check.

        * If it has non-null value, the destruction check is turned on, and

        * the value points to a local boolean variable that keeps the destroyed state.

        */

        TBool* iDestroyedPtr;

        enum TDrawState

            {

            ENotDraw = 0,

            EDrawn,

            EDrawing

            };

        TInt iDrawInvoked;

        TInt iThumbPos;

        // own

        CSmileyManager* iSmiley;        

        CSmileyCustomWrap* iSmileyWrap;

        TBool iInlineEditing;

        TBool iDisableConvertInFormat;

        TCursorSelection iVisibleRange;

        CEdwinAsyncFormat* iAsyncFormat;

        /**

         * Pointer to CEikEdwin.

         * Not own.

         */

        CEikEdwin* iEdwin;

        /**

         * Scrolled offset if using rate scroll way.

         */

        TInt iScrolledDelta;

        /**

         * If ETrue, uses rate scroll. Otherwise uses original way.

    	 */

        TBool iUseRateScroll;

        /**

         * Used with each step of dragging scrollbar to record

         * the thumb position before dragging action

         */

        TInt iScrollbarPosition;

       /**

         * Physics handler. Used only when physics feature is enabled.

         * Own.

         */

        CAknEdwinPhysicsHandler* iPhysicsHandler;

        /**

         * Content has moved down so that empty space

         * above the editor content is visible.

         */

        TBool iStartBorderExceeded;

        /**

         * Content has moved up so that empty space

         * below the editor content is visible.

         */

        TBool iEndBorderExceeded;

        /**

         * Amount of pixels out of border. In practice width

         * of empty space above or below editor content.

         */

        TInt iPixelsOutOfBorder;

        /**

         * If ETrue, text cursor was visible before drag or flick started.

         * Used to store cursor state so that it is possible to enable cursor

         * again when dragging, flicking or bounce stops.

         */

        TBool iCursorWasVisible;

        /**

         * If ETrue, ongoing scrolling is caused by moving scrollbar thumb.

         */

        TBool iScrolledByScrollBar;

         /**

         * Record formatted height of layout

         */

        TInt iRecordFormattedHeight;

        /**

         * Skins instance.

         * Not own.

         */

        MAknsSkinInstance* iSkinInstance;

        };

public:

    /**

     * The following flags may be combined with a bitwise OR to form the 

     * @c aEdwinFlags argument to @c ConstructL(TInt, ...) or the flags field 

     * of an EDWIN resource structure run through @c ConstructFromResourceL().

     *

     * These flags are duplicated in @c uikon.hrh (see @c EEikEdwinKeepDocument

     * etc.)

     */

    enum TFlags

        { // user flags

        /**  */

    	EZeroEnumValue			=0x00000000, 

        /** 

         * If set, @c CEikEdwin does not destroy its content on destruction. 

         */

    	EKeepDocument			=0x00000001,

        /** 

         * If set, the content buffer uses segmented storage (see 

         * @c CEditableText::ESegmentedStorage).

         */

    	ESegmentedStorage		=0x00000002,

        /**