/*

* 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;

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

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();

        /**

         * Enables physics.

         */

        void EnablePhysicsL();

        /**

         * 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;

        };

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,

        /**

         * The size specified in the resource used to construct the object is 

         * given in pixels, not character widths.

         */

    	EWidthInPixels			=0x00000004,

        /**

         * No automatic selection takes place. Normally the entire text is 

         * selected whenever the Edwin is created, resized or has its text 

         * set as one operation.

         */

    	ENoAutoSelection		=0x00000008,

        /**

         * If set, then whenever the control is activated the cursor is 

         * moved to the end of the text.

         */

    	EJustAutoCurEnd			=0x00000010,

        /**

         * Does not wrap the text being edited.

         */

    	ENoWrap					=0x00000020,

        /**

         * Uses a line cursor instead of a block cursor.

         */

    	ELineCursor				=0x00000040, 

        /**

         * Does not perform horizontal scrolling.

         */

    	ENoHorizScrolling		=0x00000080, 

        /**

         * If set, scroll bars required to edit long documents appear inside 

         * the Edwin. This reduces the area used to display the Edwin.

         * 

         * If not set, scroll bars appear outside the Edwin.

         */

    	EInclusiveSizeFixed		=0x00000100, 

        /**

         * Sets the Edwin’s height according to the number of lines of text 

         * supplied by the user.

         */

    	EUserSuppliedText		=0x00000200,

        /**

         * The Edwin is a window-owning control.

         */

    	EOwnsWindow				=0x00000400,

        /**

         * The Edwin does not respond to input at all.

         */

    	EDisplayOnly			=0x00000800,

        /**

         * Does not hide the selection if the Edwin loses focus.

         */

    	EAlwaysShowSelection	=0x00001000,

        /**

         * The Edwin is read-only so users cannot add text to any document it 

         * displays.

         */

    	EReadOnly				=0x00002000,

        /**

         * If set, no special attempt will be made to delete the embedded pictures cleanly.

         * 

         * This flag does not apply to Edwins which do not edit rich text.

         */

    	EAllowPictures			=0x00004000,

        /**

         * The Edwin supports undo operations.

         */

    	EAllowUndo				=0x00008000,

        /**

         * Does not allow line or paragraph breaks in the text being edited.

         */

    	ENoLineOrParaBreaks		=0x00010000,

        /**

         * Allows only ASCII characters.

         */

    	EOnlyASCIIChars			=0x00020000,

        /**

         * The Edwin is resizable.

         */

    	EResizable				=0x00040000,

        /**

         * The Edwin ignores the virtual cursor.

         */

    	EIgnoreVirtualCursor	=0x00080000,

        /**

         * No custom draw is done.

         */

    	ENoCustomDraw			=0x01000000,

        /**

         * Changes layout to Avkon style.

         */

    	EAvkonEditor			=0x02000000,

        /**

         * Hides cursor.

         */

    	EAvkonDisableCursor		=0x04000000,

        /**

         * Changes text editor to non-editable mode.

         */

    	EAvkonNotEditable		=0x08000000, 

        /**

         * Sets the @c Avkon wrapping rules ON.

         */

    	EEdwinAlternativeWrapping = 0x10000000,

    	/**

    	 * Enables tab key handling

    	 */

    	EAvkonTabsEnabled = 0x20000000,

    	/**

    	 * Disable VKB input

    	 */ 

    	EAvkonDisableVKB = 0x40000000,

    	/**

    	 * Enable Smiley Support

    	 */ 

    	EAvkonEnableSmileySupport = 0x80000000

    	};

    /**

     * Defines the possible commands for @c ClipboardL().

     */

    enum TClipboardFunc

		{

        /** Do nothing. */

		ENoClipboard,

        /** Cut. */

		ECut,

        /** Copy. */

		ECopy,

        /** Paste. */

		EPaste

		};

    /**

     * The following flags may be ORed together for text searches (see 

     * @c FindL() for example).

     */

	enum TFindFlags

		{

        /** Search progresses up the screen. */

		EFindDirectionUp	=0x01,

        /** Only whole-word matches count. */

		EFindWholeWord		=0x02,

        /** Search is case-sensitive. */

		EFindCaseSensitive	=0x04,

        /** Finds again. */

		EFindAgain			=0x08,

        /** Does not display a busy message. */

		ENoBusyMessage		=0x10,

        /**  */

		EReadOnlyFile		=0x20 // New for CKon

		};

    /**

     * When content is supplied to an Edwin using @c SetDocumentContentL(), 

     * this defines whether the new content is added to or has replaced the 

     * existing content.

     */

	enum TSetContent

		{

        /** Replaces the Edwin’s existing content. */

		EUseText,

        /** Copies the supplied content into the existing content. */

		ECopyText

		};

    /**

     * Specifies whether the Edwin owns the document it is being used to edit.

     *

     * If the Edwin owns the document, the document object is destroyed on 

     * destruction.

     */

	enum TOwnershipType

		{

        /** Document is owned by the Edwin. */

		EOwnsText,

        /** Document is owned by some other object. */

		EDoesNotOwnText

		};

    // order of hotkeys defined in resource file.  Not all applicable to plain 

    // text editors

    /**

     * Enumerates the hotkeys that are defined an @c r_eik_edwin_ctrl_hotkeys 

     * or @c r_eik_edwin_shift_ctrl_hotkeys resource.

     *

     * Not all are applicable to plain text editors.

     */

	enum TEdwinHotKeys 

		{

        /** Cut. */

		EHotKeyCut,

        /** Copy. */

		EHotKeyCopy,

        /** Paste. */

		EHotKeyPaste,

        /** Undo. */

		EHotKeyUndo,

        /** Find. */

        EHotKeyFind,

        /** Insert a character. */

		EHotKeyInsertChar,

        /** Bold. */

		EHotKeyBold,

        /** Italic. */

		EHotKeyItalic,

        /** Underline. */

		EHotKeyUnderline,

        /** Font. */

		EHotKeyFont,

        /** Insert an object. */

		EHotKeyInsertObject,

        /** Edit an object. */

		EHotKeyEditObject,

        /** Format an object. */

		EHotKeyFormatObject

		};

public: // construction and destruction

    /**

     * Destructor.

     *

     * Deletes objects and frees resources owned by this object. The Edwin’s 

     * editable text is freed if the @c EKeepDocument flag is not set.

     */

    IMPORT_C ~CEikEdwin();

    /**

     * C++ default constructor.

     *

     * Creates a new @c Edwin, FEP support for the new editor will not be 

     * present if there is insufficient memory.

     */

	IMPORT_C CEikEdwin();

    /**

     * Constructor. 

     *

     * Creates a new @c Edwin, specifying the border to use. As with the default

     * constructor, FEP support for the new editor will not be present if there

     * is insufficient memory. S60 Edwin does not support / draw any borders.

     *

     * @param aBorder The Edwin border.

     */

	IMPORT_C CEikEdwin(const TGulBorder& aBorder);

    /**

     * Handles Symbian 2nd phase construction.

     * Completes construction of a new @c Edwin, initialising its heap-stored 

     * members from the supplied arguments.

     *

     * @param aEdwinFlags Bitwise ORed combination of flags from @c TFlags. 

              Default value is 0.

     * @param aWidthInChars Specifies the width for the Edwin, in characters or

              pixels: see the @c EWidthInPixels flag. Default value is 0.

     * @param aTextLimit Maximum length for the text to present as editable. 

              Default value is 0.

     * @param aNumberOfLines Height for the Edwin, in lines. Default value 

              is 0.

     */

	IMPORT_C void ConstructL(TInt aEdwinFlags=0,

                             TInt aWidthInChars=0,

                             TInt aTextLimit=0,

                             TInt aNumberOfLines=0);

    /**

     * Sets the Edwin observer. The Edwin’s observer will be called back with 

     * control events associated with the Edwin.

     *

     * @param aEdwinObserver New observer.

     */

    IMPORT_C void SetEdwinObserver(MEikEdwinObserver* aEdwinObserver);

    /**

     * Adds an observer of standard Edwin events to the list of observers, 

     * creating the list if necessary. May be called any number of times and is

     * independent of calls to @c SetEdwinObserver.

     *

     * @param aEdwinObserver The observer to add to the list of observers.

     */

    IMPORT_C void AddEdwinObserverL(MEikEdwinObserver* aEdwinObserver);

    /**

     * Removes the specified observer from the list of observers. Does nothing 

     * if aEdwinObserver is not an observer.

     * 

     * @param aEdwinObserver The observer to remove from the list of observers.

     */

    IMPORT_C void RemoveEdwinObserver(MEikEdwinObserver* aEdwinObserver);

    /**

     * Creates the containing window for the Edwin if it does not already have one. 

     */

    IMPORT_C void SetContainerWindowL();

    /**

     * Sets the Edwin’s editable content. Before calling this function you must

     * get the @c iText pointer as @c iText is replaced by @c aText. You must 

     * also free the memory by deleting the previous @c iText contents.

     *

     * @param aText New value for the content.

     * @param aContent Specifies whether to use @c aText itself, or to copy its

     *        content. Default value is @c CEikEdwin::ECopyText.

     */

    IMPORT_C void SetDocumentContentL(CGlobalText& aText,

                        TSetContent aContent=CEikEdwin::ECopyText);

public: // from CCoeControl

    /**

     * From @c CCoeControl.

     *

     * Handles key events. 

     * 

     * @param aKeyEvent The key event.

     * @param aType The type of the event: @c EEventKeyDown, @c EEventKeyUp 

     *        or @c EEventKey.

     * @return A suitable response code.

     */

    IMPORT_C TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,

                                         TEventCode aType);

    /**

     * From @c CCoeControl.

     *

     * Responds to focus-changed events.

     *

     * @param aDrawNow Not used.

     */

    IMPORT_C void FocusChanged(TDrawNow aDrawNow);

    /**

     * From @c CCoeControl.

     *

     * Sets the Edwin as ready for drawing.

     *

     * @leave KErrNoMemory.

     */

    IMPORT_C void ActivateL();

    /**

     * From @c CCoeControl.

     *

     * Completes the construction of a new @c Edwin. This function initialises

     * the heap-stored members from an @c EDWIN resource.

     *

     * @param aReader A reader positioned for reading from an @c EDWIN resource.

     */

    IMPORT_C void ConstructFromResourceL(TResourceReader& aReader);

    /**

     * From @c CCoeControl.

     *

     * Handles pointer events.

     *

     * @param aPointerEvent Pointer event to respond to.

     */

    IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

    /**

     * From @c CCoeControl.

     *

     * Gets the minimum size of this Edwin for automatic-layout control 

     * contexts such as dialogs.

     *

     * @return Minimum size for the control.

     */

    IMPORT_C TSize MinimumSize();

    /**

     * From @c CCoeControl.

     *

     * Draws the control on request. 

     *

     * @param aRect If supplied, the rectangle in which to draw the Edwin.

     */

    IMPORT_C void Draw(const TRect& aRect) const;

    /**

     * From @c CCoeControl.

     *

     * Dims or undims the Edwin.

     *

     * @param aDimmed @c ETrue to dim the Edwin. @c EFalse to undim the Edwin.

     */

    IMPORT_C void SetDimmed(TBool aDimmed);

    /**

     * From @c CCoeControl. 

     *

     * Sets the containing window for the Edwin by copying it from the specified

     * parent. Also copies a control context from @c aParent if one has not been

     * previously set.

     *

     *@param aParent The control to set as this Edwin’s parent.

     */

    IMPORT_C void SetContainerWindowL(const CCoeControl& aParent);

    /**

     * From @c CCoeControl.

     * 

     * Gets the list of logical colours employed in the drawing of the control,

     * paired with an explanation of how they are used. Appends the list to 

     * @c aColorUseList.

     *

     * @param[out] aColorUseList The list of logical colours.

     */

    IMPORT_C virtual void GetColorUseListL(CArrayFix<TCoeColorUse>& 

                     aColorUseList) const; // not available before Release 005u

    // not available before Release 005u    

    /**

     * From @c CCoeControl.

     *

     * Handles a change to Edwin’s resources which are shared across the 

     * environment. Colours or fonts for example.

     *

     * @param aType The type of resource that was changed.

     */

    IMPORT_C virtual void HandleResourceChange(TInt aType);

    /**

     * From @c CCoeControl.

     *

     * Access to the input capabilities of the edwin.

     *

     * If this function is overrided in a subclass, the subclass should

     * obtain this class' InputCapabilities' object provider through

     * TCoeInputCapabilities::ObjectProvider() and set that as a part of

     * the subclass' InputCapabilities object provider chain to ensure

     * maximum functionality.

     *

     * @return The Edwin input capabilities.

     */

    IMPORT_C TCoeInputCapabilities InputCapabilities() const;

    /**

     * From @c CCoeControl.