/*

 * 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(__EIKRTED_H__)

 #define __EIKRTED_H__

 #if !defined(__EIKGTED_H__)

 #include <eikgted.h>

 #endif

 #if !defined(__APPARC_H__)

 #include <apparc.h>

 #endif

 #if !defined(__TXTMRTSR_H__)

 #include <txtmrtsr.h>

 #endif

 #if !defined(__GDI_H__)

 #include <gdi.h>

 #endif

 class CRichText;

 class TResourceReader;

 class TPictureHeader;

 class CEikRubberBand;

 class CBufStore;

 class CStreamStore;

 class CApaDoor;

 class CEikParserManager;

 class MEikRichTextEditorParserObserver;

 class MParser;

 /**

  * Rich text editor.

  * 

  * This is an edit window that supports rich text, including embedded objects

  * represented either by icons or glass doors. 

  *

  * @since Symbian 5.0

  */

 class CEikRichTextEditor : public CEikGlobalTextEditor, 

                            public MApaEmbeddedDocObserver, 

                            public MRichTextStoreResolver, 

                            public MPictureFactory

 	{

 public:

     /** 

      * Identifies how an embedded object should be represented.

      *

      * One of these values is specified when the object is inserted.

      */ 

 	enum TObjectFormat

 		{

         /** The object is always represented by an icon */

 		EAlwaysIconic,

         /** 

          * The object is represented by a glass door, if possible, or by icon,

          * if not.

          */

 		EGlassIfPossible

 		};

     /** 

      * Edit window attribute flags specific to the rich text editor.

      *

      * These may be specified during construction in addition to the values 

      * contained in the @c TFlags enum in class @c CEikEdwin.

      */

 	enum // user flag

 		{

         /** 

          * All embedded objects are represented by icon rather than 

          * glass doors. 

          */

         EShowAllPicturesAsIconic	=0x00100000,

         /**

          * The editor has no text parsers.

          *

          * Text parsers are used to recognise and tag special text strings,

          * e.g. URLs.

          */

         ENoTextParsers				=0x00200000,

         /**

          * When pasting text into the editor, the text is

          * stripped of all formatting.

          *

          * @since 3.2

          */

         EPasteAsPlainText           =0x00400000

 		};

 public:

     /**

      * C++ default constructor.

      */

     IMPORT_C CEikRichTextEditor();

     /**

      * C++ constructor.

      * 

      * @param aBorder Border for the rich text editor. 

      */ 

 	IMPORT_C CEikRichTextEditor(const TGulBorder& aBorder);

     /**

      * Destructor.

      */ 

     IMPORT_C ~CEikRichTextEditor();

     /** 

      * By default Symbian 2nd phase constructor is private.

      *

      * Completes construction of the rich text editor.

      *

      * The editor's paragraph and character formatting are set to default

      * values, unless the @c CEikEdwin::EUserSuppliedText flag is specified 

      * in @c aEdwinFlags.

      *

      * @param aParent If not NULL, the editor's parent control. 

      *        If NULL, the editor has no parent.

      * @param aNumberOfLines The number of lines visible in the editor. 

      *        This controls the editor's height.

      * @param aTextLimit The maximum number of characters that can be entered

      *        into the editor.

      * @param aEdwinFlags Edit window attribute flags. 

      *        See @c CEikEdwin::TFlags().

      * @param aFontControlFlags = EGulFontControlAll Flags that specify which 

      *        font-related controls should not appear in font dialogs launched 

      *        from the edit window. For instance @c EGulFontControlBold removes 

      *        the bold checkbox control. The default shows all. For possible 

      *        values, see @c gulftflg.hrh.

      * @param aFontNameFlags = EGulNoSymbolFonts The font flags. These control 

      *        whether symbol and monospace fonts should be displayed in font

      *        dialogs launched from the edit window. For possible values, see 

      *        @c gulftflg.hrh.

      */

     IMPORT_C void ConstructL(const CCoeControl* aParent,

                              TInt aNumberOfLines,

                              TInt aTextLimit,

                              TInt aEdwinFlags,

                              TInt aFontControlFlags=EGulFontControlAll,

                              TInt aFontNameFlags=EGulNoSymbolFonts);

     /** 

      * Gets a pointer to the rich text object owned by the editor.

      *

      * @return Pointer to the rich text object.

      */

     IMPORT_C CRichText* RichText() const;

     /** 

      * Launches an insert object dialog (@c CEikInsertObjectDialog),

      * and inserts a default document of the application type selected 

      * by the user.

      * 

      * The object can be displayed either as a glass door, if supported, 

      * or as an icon, and the inserted object is opened for editing.

      *

      * Displays an info message and leaves if the editor's text limit 

      * has been reached.

      * 

      * @param aFormat Specifies whether the embedded document should be 

      *        displayed as an icon or as a glass door.

      */ 

     IMPORT_C void InsertObjectL(TObjectFormat aFormat);

     /** 

      * Launches an insert object dialog (@c CEikInsertObjectDialog),

      * and inserts a default document of the application type selected 

      * by the user.

      * 

      * The object is displayed as a glass door rather than as an icon, 

      * if supported and the inserted object is opened for editing.

      *

      * Displays an info message and leaves if the editor's text limit 

      * has been reached.

      *

      * Default is @c EGlassIfPossible.

      */

     IMPORT_C void InsertObjectL(); // defaults to EGlassIfPossible

     /** 

      * Creates and inserts a default document of the specified 

      * application type.

      * 

      * @c CApaProcess::AddNewDocumentL() is used to create the document.

      * 

      * The object can be displayed either as a glass door, if supported, 

      * or as an icon, and the inserted object is opened for editing.

      *

      * Displays an info message and leaves if no suitable application DLL 

      * can be found, or if the editor's text limit has been reached.

      *

      * @since Symbian 7.0

      * @param aAppDllName Filename of the application DLL.

      * @param aAppDllUid UID of the application. The default is @c KNullUid.

      * @param aFormat Specifies whether the embedded document should be 

      *        displayed as an icon or as a glass door.

      */

     IMPORT_C void InsertObjectL(const TDesC& aAppDllName,

                                 TUid aAppDllUid,

                                 TObjectFormat aFormat);

     /** 

      * Creates and inserts a new embedded object of the specified type.

      *

      * First, an attempt is made to find an extended picture factory that

      * supports the insertion of pictures of the specified type. If one is

      * not found, the function leaves; if one is found, the picture is inserted

      * at the cursor position.

      *

      * Displays an info message and leaves if the editor's text limit has

      * been reached.

      * 

      * @since Symbian 6.1

      * @param aPictureType The picture type.

      * @param aData The base address of the data. 

      * @leave KErrNotSupported No picture factory which supports the specified 

      *                         type is available in the control's @c Uikon 

      *                         environment.

      */

     IMPORT_C void InsertObjectL(TUid aPictureType,

                                 CBase* aData);

     /** 

      * Re-edits the embedded object at the cursor position.

      *

      * If there is no embedded object at the cursor position, or if there is a 

      * selection, an info message is displayed.

      *

      * If there is a valid object at the cursor position, it is opened for 

      * editing (or for viewing if the editor is read-only).

      */

     IMPORT_C void ReEditObjectL();

     /** 

      * Gets the document position and checks whether there is an embedded 

      * object at the cursor position.

      *

      * If there is no embedded object at the cursor position, or if there 

      * is a selection, an info message is displayed.

      *

      * @return The document position of the embedded object, or 

      *         @c KErrNotFound if there is no embedded object at the cursor 

      *         position, or if there is a selection

      */

     IMPORT_C TInt ObjectCursorPos() const;

     /**

      * Tests whether there is an embedded object at the cursor position.

      *

      * If there is one, it is opened for editing (or for viewing if the editor

      * is read-only).

      *

      * @return @c ETrue if there is an embedded object at the cursor 

      *         position and it could be opened. @c EFalse if there is no 

      *         embedded object at the cursor position, or if the object has

      *         a NULL UID.

      */ 

     IMPORT_C TBool CheckForObjectL();

     /**

      * Launches a format object dialog (@c CEikFormatObjectDialog) if there 

      * is an embedded object at the cursor position, and the object supports 

      * being displayed as a glass door.

      *

      * If the object does not support being displayed as a glass door, an 

      * object information dialog (@c CEikObjectInfoDialog) is launched instead.

      *

      * If the embedded object's associated application cannot be found, an 

      * info message is displayed and the function leaves.

      *

      * The function has no effect if there is no embedded object at the cursor

      * position.

      */ 

     IMPORT_C void EditPictureFormatL();

     /**

      * Handles a change to the format of an embedded object, by updating the 

      * view, the scroll bars and reporting the event to its observers.

      *

      * There is no need to call this function after calling 

      * @c EditPictureFormatL().

      */

     IMPORT_C void PictureFormatChangedL();

     /**

      * Gets a pointer to the embedded object located at the specified position. 

      *

      * If the object is not in memory, the function loads it.  

      *

      * If the object's associated application cannot be found, an info message

      * is displayed and the function leaves.

      *

      * @param aDoor On return, the embedded document's wrapper object (icon or 

      *        glass door).

      * @param aDoc On return, the embedded document.

      * @param aDocPos The document position in the editor at which the embedded 

      *        object is located.

      */

     IMPORT_C void GetEmbeddedAppL(CApaDoor*& aDoor,

                                   CApaDocument*& aDoc,

                                   TInt aDocPos);

     /** 

      * Changes all embedded objects displayed as glass doors into temporarily 

      * iconic.

      * 

      * The function operates throughout the editor.

      *

      * Only needed when pictures are temporarily iconic. 

      *

      * Has no effect if there are no embedded objects in the editor or if the 

      * @c EShowAllPicturesAsIconic attribute flag was set during construction.

      */

     IMPORT_C void UpdatePictureFormatL(); 

     /**

      * Changes all embedded objects displayed as glass doors into temporarily 

      * iconic.

      * 

      * The function operates over a specified range of characters.

      *

      * Has no effect if there are no embedded objects in the editor or if the 

      * @c EShowAllPicturesAsIconic attribute flag was set during construction.

      *

      * Only needed when pictures are temporarily iconic.

      *

      * @param aStartPos The start position.

      * @param aLength The number of characters, beginning at @c aStartPos over 

      *        which the function operates.

      */

     IMPORT_C void UpdatePictureFormatL(TInt aStartPos,TInt aLength); 

     /** 

      * Changes the size of the icons used to represent embedded objects.

      *

      * Any existing iconic doors can be updated to the new size by calling 

      * @c UpdatePictureSizeL().

      *

      * @param aSize The new iconic door size in twips.

      */ 

     IMPORT_C void SetDefaultIconicDoorSize(const TSize& aSize); 

     /** 

      * Gets the size of iconic doors.

      * 

      * @return The size of iconic doors. 

      */ 

     IMPORT_C const TSize& DefaultIconicDoorSize() const;

     /** 

      * Changes the size of all icons representing embedded objects to the 

      * default iconic door size.

      *

      * Also updates any objects currently displayed as glass doors, so that

      * if displayed as icons, they will use the correct size. 

      *

      * The function operates throughout the editor.

      */

     IMPORT_C void UpdatePictureSizeL();

     /**

      * Changes the size of all icons representing embedded objects to the 

      * default iconic door size.

      *

      * Also updates any objects currently displayed as glass doors, so that 

      * if displayed as icons, they will use the correct size. 

      *

      * The function operates over a specified range of characters.

      *

      * @param aStartPos The start position.

      * @param aLength The number of characters, beginning at @c aStartPos over

      *        which the function operates.

      */

     IMPORT_C void UpdatePictureSizeL(TInt aStartPos,TInt aLength);

     /** 

      * Sets a parser observer.

      *

      * If the @c CEikEdwin::ENoTextParsers attribute flag was specified on 

      * construction, this function has no effect.

      *

      * Its @c HandleCursorOverParserL() function is called when the cursor is 

      * positioned over text that has been tagged by the parser, for instance 

      * a URL.

      *

      * @param aObserver The parser observer.

      */ 

     IMPORT_C void SetParserObserver(

                     MEikRichTextEditorParserObserver* aObserver);

     /**

      * Activate/Disable phone number grouping.

      *

      * @param aEnable @c ETrue if phone number grouping is to be activated,

      *        @c EFalse otherwise.

      */ 

     IMPORT_C void SetPhoneNumberGrouping( TBool aEnable );

 public: // from CCoeControl

     /** 

      * From @c CCoeControl.

      * 

      * Handles key events.

      *

      * Has no effect (apart from returning @c EKeyWasConsumed) if the 

      * @c CEikEdwin::EDisplayOnly attribute flag was specified on construction.

      *

      * Handles rich text-specific hot keys, for instance to insert an object; 

      * otherwise calls @c CEikGlobalTextEditor::OfferKeyEventL(). 

      *

      * @param aKeyEvent The key event.

      * @param aType The type of the event. The editor only consumes events of 

      *        type @c EEventKey.

      * @return Indicates whether or not the editor consumed the 

      *         key event.

      */

     IMPORT_C TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);

     /**

      * From @c CCoeControl.

      * 

      * Handles pointer events inside the editor.

      *

      * Has no effect if the @c CEikEdwin::EDisplayOnly attribute flag was 

      * specified on construction.

      * 

      * @param aPointerEvent The pointer event to be handled.

      */

     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

     /** 

      * From @c CCoeControl.

      *

      * Completes the construction of the rich text editor from a resource file.

      *

      * The editor's paragraph and character formatting are set to default 

      * values, unless the @c CEikEdwin::EUserSuppliedText flag is specified in 

      * the resource.

      *

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

      *        RTXTED resource.

      */

     IMPORT_C void ConstructFromResourceL(TResourceReader& aReader);

     /** 

      * From @c CCoeControl. 

      * 

      * Activates the editor so that it is ready for use.

      *

      * For instance, the text view is created, the editor is set to observe its

      * rich text object, the editor's parser manager is set up, which handles

      * the changes that occur when the cursor is moved over tagged text

      * (for instance a URL), and all embedded objects are set to be displayed

      * as icons, of the default size.

      */ 

     IMPORT_C void ActivateL();

 private:

     /**

     * From CAknControl.

     */

     IMPORT_C void* ExtensionInterface( TUid aInterface );

 public: // from CEikEdwin

     /** 

      * From @c CEikEdwin.

      * 

      * Copies the contents of one text object into another.

      *

      * @param[in] aInText The rich text object to copy.

      * @param[out] aOutText On return, contains a copy of @c aInText.

      * @panic 26 In debug mode, if either @c aInText or @c aOutText is @c NULL.

      */ 

     IMPORT_C void CopyDocumentContentL(CGlobalText& aInText,CGlobalText& aOutText);

 protected:

     /** 

      * Internal flags used for indicating operations. 

      */

     enum // internal flags

 		{

         /** Crop from left. */ 

         ECropFromLeft			=0x00010000,

         /** Crop from right. */

         ECropFromRight			=0x00020000,

         /** Crop from top. */

         ECropFromTop			=0x00040000,

         /** Crop from bottom. */ 

         ECropFromBottom			=0x00080000,

         /** Object is being re-edited. */

         EReEditingObject		=0x00100000

 		};

 protected: // from CCoeControl

     /** 

      * From @c CCoeControl.

      *

      * Writes the internal state to the specified stream.

      * 

      * @param aWriteStream Target stream.

      */

     IMPORT_C void WriteInternalStateL(RWriteStream& aWriteStream) const;

 protected: // from MEditObserver

     /** 

      * From @c MEditObserver. 

      * 

      * This member is internal an not meant to be used. 

      *

      * @param aStartEdit Start position for editing.

      * @param aEditLength The length of the edited object.

      */

     IMPORT_C void EditObserver(TInt aStartEdit,TInt aEditLength);

 private: // from CoeControl

     IMPORT_C void Draw(const TRect& aRect) const;

     IMPORT_C void Reserved_2();

 private: // from CEikEdwin

     IMPORT_C void HandleTextPastedL(TInt aStartPos,TInt& aLength);

     IMPORT_C void Reserved_3();

 private: // from MApaEmbeddedDocObserver

     IMPORT_C void NotifyExit(TExitMode aMode);

 private: // from MRichTextStoreResolver

     IMPORT_C const CStreamStore& StreamStoreL(TInt aPos) const;

 private: // from MPictureFactory

     IMPORT_C void NewPictureL(TPictureHeader& aHdr,const CStreamStore& aDeferredPictureStore) const;

 private:

     void CommonConstructL();

     static TInt InsertEmbeddedDocL(TAny *aThis);

     static TInt DeleteEmbeddedDoc(TAny *aThis);

     static TInt UpdateEmbeddedDocL(TAny* aThis);

     static TInt TryDeleteEmbeddedDocL(TAny *aThis);

     void InsertPictureL(const TPictureHeader& aPictureHeader);

     void DoInsertPictureL(TBool& aFormatHasChanged,const TPictureHeader& aPictureHeader);

     void DoReEditObjectL(TInt aDocPos);

     void RoomForObjectL();

     void InsertObjectL(CApaDocument* aDoc,TObjectFormat aFormat);

     void SetTextObserver(CRichText& aText);

     inline void DoReportEdwinEventL(MEikEdwinObserver::TEdwinEvent aEventType);

 protected:

     /** 

      * Default size of iconic door.

      */

     TSize iDefaultIconicDoorSize;

 private:

     TPictureHeader iEmbeddedDoc;

     CIdle* iEmbeddedDocUpdate;

     CBufStore* iBufStore;

     CEikParserManager* iParserManager;

 private:

     friend class CEikParserManager;

 public: // new methods

     /**

      * Force everything to be parsed.

      */ 

     IMPORT_C void RefreshParsersL();

     };

 class MEikRichTextEditorParserObserver

 	{

 public:

 	virtual void HandleCursorOverParserL(const TDesC& aDoItText)=0;

 	};

 inline void CEikRichTextEditor::DoReportEdwinEventL(MEikEdwinObserver::TEdwinEvent aEventType)

 	{ReportEdwinEventL(aEventType);}

 #endif  // __EIKRTED_H__

 // End of file