diff -r aecbbf00d063 -r d48ab3b357f1 classicui_pub/editors_api/inc/EIKEDWIN.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/classicui_pub/editors_api/inc/EIKEDWIN.H Wed Sep 01 12:16:19 2010 +0100 @@ -0,0 +1,3220 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // class CCenRepNotifyHandler; +#include // 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 iText; + /** Text to replace it with. */ + TBuf 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; + + /** + * Record enableSmiley is supported. + */ + TBool iEnableSmileySupported; + + /** + * Record if text view has been actually hidden. + */ + TBool iTextViewHidden; + }; + +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& + 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. + * + * This method sets the input capabilities of the edwin. Ownership of the + * T-class is not transferred. + * + * @param aInputCapabilities Reference to an input capabilities object + * on the heap. + * @leave KErrNoMemory Edwin FEB support object is not created. + */ + IMPORT_C void SetInputCapabilitiesL(const TCoeInputCapabilities& + aInputCapabilities); + + /** + * From @c CCoeControl. + * + * In debug mode writes the internal state to the given stream. Does + * nothing in release mode. + * + * @param[out] aWriteStream A stream for writing the internal state. + */ + IMPORT_C void WriteInternalStateL(RWriteStream& aWriteStream) const; + +private: + + /** + * From CAknControl + */ + IMPORT_C void* ExtensionInterface( TUid aInterface ); + +public: // from MEikScrollBarObserver + + /** + * From @c MEikScrollBarObserver. + * + * Handles scrollbar key events. + * + * @param aScrollBar The scrollbar. + * @param aEventType The type of key event. + */ + IMPORT_C void HandleScrollEventL(CEikScrollBar* aScrollBar, + TEikScrollEvent aEventType); + +public: // from CTextView::MObserver + + /** + * From @c CTextView::MObserver. + * + * Called after reformatting but before redisplay so that edit windows + * etc. can be resized. + * + * @param aTextView Not used. + */ + IMPORT_C void OnReformatL(const CTextView* aTextView); + +public: + + /** + * Gets the number of characters in the document. + * + * @return The number of characters in the document. + */ + IMPORT_C TInt TextLength() const; + + /** + * Gets the cursor’s position within the document. + * + * @return The cursor’s position within the document. + */ + IMPORT_C TInt CursorPos() const; + + /** + * Gets the number of characters including non-printing characters within + * the selection. + * + * @return The number of characters within the selection. + */ + IMPORT_C TInt SelectionLength() const; + + /** + * Gets the cursor selection. If no text view is associated to the Edwin + * this returns @c TCursorSelection(0,0). + * + * @return The current selection. + */ + IMPORT_C TCursorSelection Selection() const; + + /** + * Removes the selection and any composition text. The cursor position is + * unaffected. If there is no selected region, this function has no effect. + */ + IMPORT_C void ClearSelectionL(); + + /** + * Sets the text selection. Highlights the selected area and makes the new + * cursor position visible. Any previous selection is cancelled. This + * function also updates the scroll bar thumbs if present. + * + * @param aCursorPos The cursor’s position. + * @param aAnchorPos The anchor’s position. + */ + IMPORT_C void SetSelectionL(TInt aCursorPos,TInt aAnchorPos); + + /** + * Sets the cursor’s position within the document. If the new position is + * not visible the text is scrolled so that the line containing the + * cursor is visible. This function also updates the scroll bar thumbs + * if present. + * + * @param aCursorPos New cursor position. + * @param aSelect @c ETrue to extend the cursor’s selection to the new + * position. @c EFalse otherwise. + */ + IMPORT_C void SetCursorPosL(TInt aCursorPos,TBool aSelect); + + /** + * Selects the entire document. + */ + IMPORT_C void SelectAllL(); + + /** + * Recalculates the screen width of an Edwin from the specified number + * of character widths. This is called during construction. If the + * Edwin only allows editing of numbers, the width of the zero + * character (0) is used; otherwise + * @c CFont::MaxNormalCharWidthInPixels() is used. + * + * If the @c EWidthInPixels flag has been set, the @c aWidthInChars + * argument is measured in pixels, not characters. + * + * @param aWidthInChars Width in either pixels or characters. + */ + IMPORT_C void CalculateWidth(TInt aWidthInChars); + + /** + * Copies the entire document’s content into a descriptor. It is the + * caller's responsibility to provide a large enough buffer. + * + * @param[out] aDes An initialised descriptor which on return contains a + * copy of the content of this Edwin. + */ + IMPORT_C void GetText(TDes& aDes) const; + + /** + * Gets a new buffer containing a copy of the whole text document. + * + * @return A new copy of the document text. + */ + IMPORT_C HBufC* GetTextInHBufL() const; + + /** + * Sets the document text of this Edwin from the contents of a descriptor. + * This function removes any pictures, any invalid characters and cancels + * any previous selection. + * + * @param aDes Descriptor from which to copy. + */ + IMPORT_C void SetTextL(const TDesC* aDes); + + /** + * Handles cut, copy and paste commands. This function also reports a + * change of state of the control to the observer when necessary. + * + * @param aClipboardFunc Clipboard operation. + */ + IMPORT_C void ClipboardL(TClipboardFunc aClipboardFunc); + + /** + * Inserts a field at the current cursor position. If a selection was made + * the field replaces that selection. + * + * @param aField Text field to insert. + * @param aFieldType Type of the field. + */ + IMPORT_C void InsertFieldL(CTextField* aField, TUid aFieldType); + + /** + * Updates all the fields in the document. + */ + IMPORT_C void UpdateAllFieldsL(); + + /** + * Updates any text field at the current cursor position. Updating involves + * calculating the new value for the field, and replacing the field’s + * existing text content with the new text. + * + * This function does nothing if the cursor is not within a text field. + */ + IMPORT_C void UpdateCurrentFieldL(); + + /** + * Counts and returns the number of words in the document. + * + * @return The number of words in the document. + */ + IMPORT_C TInt CountWords(); + + /** + * Inserts the contents of a text file into the text being edited at the + * current cursor position. + * + * @param aFileName The file to open and read. + * @param aTextOrganisation How to handle line breaks. Default value is + * @c CPlainText::EOrganiseByLine. + */ + IMPORT_C void InsertFromTextFileL(const TFileName &aFileName, + const CPlainText::TTextOrganisation + aTextOrganisation=CPlainText::EOrganiseByLine); + + /** + * Uses @c SetScrollBarsL() to set the scrollbars. + * + * @param aPtr Pointer to @c CEikEdwin instance. + * @return Integer value of @c EFalse. + */ + IMPORT_C static TInt IdleL(TAny *aPtr); + + /** + * Gets a pointer to the Edwin’s document contents. + * + * @return A @c CPlainText pointer which contains the + * document. + */ + IMPORT_C CPlainText* Text() const; + + // this is particularly important for when the front-end processor is + // inline-editing a CEikEdwin + /** + * Cancels any current transaction with the Edwin’s front-end processor. + * Any front-end input windows are removed, and any highlighted text being + * edited in the Edwin is removed. The Edwin is rolled back to the state + * it was in before the FEP transaction started. This function is called + * by @c CEikEdwin itself when the document content, the cursor position + * or the current selection is changed. + * + * Cancelling outstanding FEP transactions before performing operations + * on the text programmatically is particularly important when the + * front-end processor is inline-editing an Edwin. + * + */ + IMPORT_C void CancelFepTransaction(); + + /** + * Handles all modifications made by reformatting the entire document. + * Calls @c CEikEdwin::FormatText() and redraws Edwin contents and + * scroll bars if they are ready to be redrawn. + */ + IMPORT_C void HandleTextChangedL(); + + /** + * Gets the width used for laying out the text inside the Edwin in pixels. + * This may be larger or smaller than the width of the Edwin itself. + * See @c SetWysiwygModeOn() for example. + * + * @return Width of the text layout area in pixels. + */ + IMPORT_C TInt LayoutWidth() const; + + /** + * Formats and draws a new document, updates scrollbars if necessary. + */ + IMPORT_C void NotifyNewDocumentL(); + + /** + * Reformats and redraws the document, updates scrollbars if necessary. + */ + IMPORT_C void NotifyNewFormatL(); + + /** + * Gets true if a substring is present in the text being edited before or + * after the cursor position. If @c aFindText is NULL, then the current + * word or selection will be searched for again. + * + * @param aFindText The substring to search for. + * @param aFindFlags See @c TFindFlags. Default value is 0. + * @return @c ETrue if aFindText is found. + */ + IMPORT_C TBool FindL(const TDesC* aFindText,TInt aFindFlags=0); + + /** + * Gets the cursor position of the matching text in the document. The + * search starts from @c aPos. If @c aFindText is NULL, then the + * current word or selection will be searched for. If the substring + * cannot be found, this function returns @c KErrNotFound. + * + * @param aFindText The substring to search for. + * @param aPos Starting position for the find. + * @param aFindFlags See @c TFindFlags. + * @return KErrNotFound if the text was not found, otherwise the + * position of the matched substring. + */ + IMPORT_C TInt FindTextL(const TDesC* aFindText,TInt aPos,TInt aFindFlags); + + /** + * Replaces the highlighted text. See @c SEdwinFindModel struct. + * + * @param[in,out] aFindModel Pointer to the replacement text. + */ + IMPORT_C void ReplaceL(SEdwinFindModel* aFindModel); + + /** + * Replaces all occurrences of a string with new text. Both old and new + * text are held in @c aFindModel. + * + * @param[in,out] aFindModel Pointer to the replacement text. + * @leave This function will leave if the replace operation fails + * unexpectedly. + */ + IMPORT_C void ReplaceAllL(SEdwinFindModel* aFindModel); + + /** + * Gets the current word or selection and searches for it. This function + * is called by @c FindL() and @c FindTextL() when no text to search for + * is given. + * + * @param aFindText An empty descriptor. + */ + IMPORT_C void GetFindText(TDes* aFindText); + + /** + * Updates scrollbars. + */ + IMPORT_C void UpdateScrollBarsL(); + + /** + * Creates the Edwin scroll bar frame with no pre-allocation of memory + * for scroll bars. + * + * @return The scroll bar frame. + */ + IMPORT_C CEikScrollBarFrame* CreateScrollBarFrameL(); + + /** + * Creates a pre-allocated scroll bar frame. + * + * @return Pre-allocated scroll bar frame. + */ + inline CEikScrollBarFrame* CreatePreAllocatedScrollBarFrameL(); + + /** + * Gets the scroll bar frame surrounding this Edwin. + * + * @return Pointer to this Edwin’s scroll bar frame. + */ + inline CEikScrollBarFrame* ScrollBarFrame(); + + /** + * Sets word wrapping on or off. + * + * @param aWrapIsOn @c ETrue enables word wrapping, @c EFalse disables + * word wrapping. + */ + IMPORT_C void SetWordWrapL(TBool aWrapIsOn); + + /** + * Gets the width of a line cursor in pixels. + * + * @return Always 0. + */ + IMPORT_C virtual TInt LineCursorWidth() const; + + /** + * Sets the zoom factor of the document and reformats the document. + * + * @param aZoomFactor New value for the zooming factor. + */ + IMPORT_C void SetZoomFactorL(TZoomFactor* aZoomFactor); + + /** + * Sets the Edwin’s background colour. + * + * @param aBackground New value for the background colour. + */ + IMPORT_C void SetBackgroundColorL(TRgb aBackground); + + /** + * Sets the format mode to be WYSIWYG. + * + * @param aLayoutWidth Formatting width in twips. + * @param aDevice Mapping between twips and pixels on the target device. + */ + IMPORT_C void SetWysiwygModeOn(TInt aLayoutWidth, + MGraphicsDeviceMap* aDevice); + + /** + * Switches off the WYSIWYG mode. This function sets the new format mode + * to be @c EFScreenMode. + */ + IMPORT_C void SetWysiwygModeOff(); + + /** + * Updates the text wrap width. This function is for use in WYSIWYG mode + * only. + * + * @param aLayoutWidth New width to wrap text at in WYSIWYG mode in twips. + */ + IMPORT_C void UpdateLayoutWidth(TInt aLayoutWidth); + + /** + * Sends the Edwin’s document using an infra red beamer. + */ + IMPORT_C void SendDataOverIrL(); + + /** + * Receives an Edwin document using an infra red beamer. + * This function will leave if the data received is not a suitable type + * to be pasted into the Edwin. + */ + IMPORT_C void ReceiveDataOverIrL(); + + /** + * Controls the formatting mode of the editor. + * + * The length of the text is compared against current formatting mode thresholds. + * (See method SetUpperFullFormattingLength). If the length is greater than the + * upper limit of full formatting, then the editor is set to "band" formatting, + * where the editor attempts to format as little as is needed, e.g. the visible part + * of the editor. If the text length is less than the lower limit of band formatting, + * then the formatting mode is switched to full document formatting. + * + * This method performs an immediate re-formatting of all or part of the text with the new formatting mode. + * + * @param aIsNewDoc If EFalse, attempts to perform re-formatting based upon current formatting + * If not EFalse, whole document it formatted from scratch + * Note: This parameter is ignored if aReFormat is EFalse + */ + IMPORT_C void SetAmountToFormatL(TBool aIsNewDoc=EFalse); + + /** + * Controls the formatting mode of the editor. + * + * The length of the text is compared against the current formatting mode thresholds. + * (See method SetUpperFullFormattingLength). If the length is greater than the + * upper limit of full formatting, then the editor is set to "band" formatting, + * where the editor attempts to format as little as is needed, e.g. the visible part + * of the editor. If the text length is less than the lower limit of band formatting, + * then the formatting mode is switched to full document formatting. + * + * This method has a flag to allow any immediate re-formatting to be suppressed. + * Formatting text can be a time-consuming operation. If the client is able to + * ensure that no reformatting is needed, (for instance if a further re-formatting + * API is going to be called later) then the reformatting flag can be called + * with EFalse. Otherwise, a re-format will take place within this method. + * + * @since 3.1 + * @param aIsNewDoc If EFalse, attempts to perform re-formatting based upon current formatting + * If not EFalse, whole document it formatted from scratch + * Note: This parameter is ignored if aReFormat is EFalse + * @param aReFormat If EFalse, do not perform any re-formatting + */ + IMPORT_C void SetAmountToFormatL( TBool aIsNewDoc, TBool aReFormat ); + + /** + * Sets the @c EPasteFromIrStore flag. + * + * @param aPasteFromIrStore @c ETrue to set the @c EPasteFromIrStore flag. + * @c EFalse to remove the @c EPasteFromIrStore flag. + */ + IMPORT_C void SetPasteFromIrStore(TBool aPasteFromIrStore); + + /** + * Copies the contents of a stream store to the current cursor position, + * replacing any selected text. This function is used to paste data from + * the clipboard. + * + * @param[out] aStore Store from which to read. + * @param[in] aDict Stream dictionary. + */ + IMPORT_C void PasteFromStoreL(CStreamStore& aStore, + CStreamDictionary& aDict); + + /** + * Copies the highlighted text into a stream store. + * + * @param[out] aStore Store to write to. + * @param[in] aDict Stream dictionary. + */ + IMPORT_C void CopyToStoreL(CStreamStore& aStore, CStreamDictionary& aDict); + + /** + * Sets the text view margins. + * + * @param aMargins New value for the view’s margins. + */ + IMPORT_C void SetBorderViewMargins(TMargins8 aMargins); + + /** + * Forces the scrollbars to update now; this is a synchronous function. + */ + IMPORT_C void ForceScrollBarUpdateL(); + + /** + * Sets whether the Edwin owns a document. Edwins can either be used as a + * standalone text editor control, or as an editor for text owned by + * another object. The document ownership setting determines whether the + * Edwin or another object owns the document. + * + * @param aOwner Whether Edwin or another object owns the document. + * See @c TOwnershipType. + */ + IMPORT_C void SetDocumentOwnership(TOwnershipType aOwner); + + /** + * Sets the maximum number of characters that can be inserted. + * + * @param aLimit New maximum for the number of characters that can be + * inserted. + */ + IMPORT_C void SetTextLimit(TInt aLimit); + + /** + * Displays a dialog allowing the user to choose a character from the + * character map. The selected character is inserted into the Edwin + * at the current cursor position. + */ + IMPORT_C void RunCharMapDialogL(); + + /** + * Gets the text view margins. + * + * @return The text view margins. + */ + IMPORT_C TMargins8 Margins() const; + + /** + * Gets the upper limit for formatting. This returns the value of + * @c KFullFormattingUpperThreshold which determines the maximum number of + * characters that can be formatted, if it is exceeded then only visible + * text is formatted. This is used with @c KPartialFormattingLowerThreshold + * to control the extent of text formatting. + * + * @return The value of @c KFullFormattingUpperThreshold. + */ + IMPORT_C TInt UpperFullFormattingLength() const; + + /** + * Gets the lower limit for formatting. This returns the value of + * @c KPartialFormattingLowerThreshold which determines when a switch is + * made from formatting only visible text to formatting all text. When the + * text length exceeds the @c KFullFormattingUpperThreshold only visible + * text is formatted. If some characters are deleted so that the text + * length is less than @c KFullFormattingUpperThreshold the entire text + * is still not formatted. Instead, reformatting occurs only when the + * number of characters is less than the value of + * @c KPartialFormattingLowerThreshold. + * + * @return The value of @c KPartialFormattingLowerThreshold. + */ + IMPORT_C TInt LowerPartialFormattingLength() const; + + /** + * Sets the Edwin’s read-only flag so that documents displayed by Edwin + * cannot be edited by users. + * + * @param aReadOnly @c ETrue to set Edwin to display documents as + * read-only. @c EFalse otherwise. + */ + IMPORT_C void SetReadOnly(TBool aReadOnly); + + /** + * Determines whether the document being edited with Edwin is read-only. + * + * @return @c ETrue if the document being edited is read-only. + * @c EFalse otherwise. + */ + IMPORT_C TBool IsReadOnly() const; + + /** + * Gets editor flags from the editor. + * @return editor flags if existed + * @or return KErrNotFound + */ + IMPORT_C TInt CEikEdwin::AknEditorFlags(); + + + + /** + * Determines whether the document being edited is read only. Displays + * a message with @c CEikonEnv::InfoMsg() if the document is set as + * read-only. + */ + IMPORT_C void CheckNotReadOnlyL(); + + /** + * Sets whether the document accepts pictures. + * + * @param aAllow @c ETrue sets the document to accept pictures, @c EFalse + * sets the document to not accept pictures. + */ + IMPORT_C void SetAllowPictures(TBool aAllow); + + /** + * Removes unwanted pictures. If @c EAllowPictures has been set, returns + * immediately. Otherwise, this function checks the document text between + * two bounds and removes all pictures in that range. + * + * @param aStartPos Where to start looking for unwanted pictures. + * @param aLength Where to stop. + */ + IMPORT_C void CheckRemovePictures(TInt aStartPos,TInt aLength); + + /** + * Sets the minimum gap between text and the right hand edge of the Edwin + * when text is wrapped. This value is used to calculate the layout area + * for text. + * + * @param aGap Size of the gutter in pixels. + */ + IMPORT_C void SetRightWrapGutter(TInt aGap); + + /** + * Undoes the most recent text operation when the Edwin supports this + * feature and when the undo store is not empty. + */ + IMPORT_C void UndoL(); + + /** + * Deletes the undo store. + */ + IMPORT_C void ClearUndo(); + + /** + * Sets whether the undo operation is permitted. + * + * @param aAllow ETrue to permit undo operations. EFalse to not permit undo + * operations. + */ + IMPORT_C void SetAllowUndo(TBool aAllow); + + /** + * Gets whether Edwin is set to support the undo command. + * + * @return @c ETrue if edits can be undone. @c EFalse if edits cannot + * be undone. + */ + IMPORT_C TBool SupportsUndo() const; + + /** + * Tests whether an undo is possible. Returns @c ETrue only if the undo + * store is available to Edwin. + * + * @return @c ETrue if the undo store is available. @c EFalse if the + * undo store is not available. + */ + IMPORT_C TBool CanUndo() const; + + /** + * Sets whether picture characters and/or punctuation should be treated as + * word delimiters in addition to whitespace. + * + * @param aPicture @c ETrue if picture characters should be treated as + * delimiters for words. + * @param aPunctuation @c ETrue if punctuation should be treated as + * delimiters for words. + */ + IMPORT_C void SetWordDelimiters(TBool aPicture,TBool aPunctuation); + + /** + * Gets the start position and the length of the word in which the + * specified document position is located. + * + * @param[in] aCurrentPos A position within a word in the text. + * @param[out] aStartPos Returns the start position of the word. + * @param[out] aLength Returns the word’s length. + */ + IMPORT_C void GetWordInfo(TInt aCurrentPos, + TInt& aStartPos, + TInt& aLength) const; + + /** + * Sets the new cursor position. If the cursor is no longer visible the + * document is scrolled to display the line containing the new cursor + * position. Scrollbars are also updated if present. + * + * @param aMovement The cursor movement. + * @param aSelect If @c ETrue, the selection is extended. This corresponds + * to holding down the Shift key on a machine keyboard. + */ + IMPORT_C void MoveCursorL(TCursorPosition::TMovementType aMovement, + TBool aSelect); + + /** + * Scrolls the text either horizontally or vertically without affecting + * the cursor’s position. + * + * @param aMovement The cursor's movement. + */ + IMPORT_C void MoveDisplayL(TCursorPosition::TMovementType aMovement); + + /** + * Removes all non-ASCII characters from the specified text. This can be + * used to remove Unicode characters where they are not valid characters + * for example. + * + * @param aStartPos The start position in the text. + * @param aLength The number of characters, beginning with aStartPos to + * check. + */ + IMPORT_C void CheckValidityOfChars(TInt aStartPos,TInt aLength); + + /** + * Sets the @c EOnlyASCIIChars flag. + * + * @param aASCIIOnly If @c ETrue the EOnlyASCIIChars flag will be set. If + * @c EFalse the EOnlyASCIIChars flag will be removed. + */ + IMPORT_C void SetOnlyASCIIChars(TBool aASCIIOnly); + + /** + * Tests whether the @c EOnlyASCIIChars flag is set. + * + * @return @c ETrue if the @c EOnlyASCIIChars flag is set. + */ + IMPORT_C TBool OnlyASCIIChars() const; + + /** + * Gets the average number of lines shown in Edwin’s view. + * + * @return The average number of lines. + */ + inline TInt AvgLinesInViewRect() const; + + /** + * Gets the average number of characters on a line. + * + * @return The average number of characters on a line. + */ + inline TInt AvgCharsPerLine() const; + + /** + * Sets the average number of lines displayed in Edwin’s view. + * + * @param aAvgLines The average number of lines to display. + */ + inline void SetAvgLinesInViewRect(TInt aAvgLines); + + /** + * Sets the average number of characters per line. + * + * @param aAvgChars The average number of characters per line. + */ + inline void SetAvgCharsPerLine(TInt aAvgChars); + + /** + * Sets the Edwin size observer. Does not imply transfer of ownership. + * + * @param aEdwinSizeObserver The Edwin size observer. + */ + IMPORT_C void SetEdwinSizeObserver(MEikEdwinSizeObserver* + aEdwinSizeObserver); + + /** + * Gets the minimum Edwin height. + * + * @return The minimum Edwin height. + */ + IMPORT_C TInt MinimumHeight() const; + + /** + * Gets the maximum Edwin height. + * + * Please do not use the following method for deciding heights if you are + * using edwins with Maximum Heights in forms. Use @c MaximumHeightInLines + * instead. + * + * @return The maximum Edwin height. + */ + IMPORT_C TInt MaximumHeight() const; + + /** + * Sets the minimum Edwin height. This function also increases the maximum + * Edwin height if its value is less than @c aHeight. + */ + IMPORT_C void SetMinimumHeight(TInt aHeight); + + /** + * Sets the maximum Edwin height. This function also decreases the minimum + * Edwin height if its value is greater than @c aHeight. + * + * Please do not use the following method for setting maximum heights if + * you are using edwins with maximum heights in forms. Use + * @c MaximumHeightInLines instead. + * + * @param aHeight The maximum Edwin height. + */ + IMPORT_C void SetMaximumHeight(TInt aHeight); + + void OnEditorStateFlagChange( TInt aOldFlag, TInt aNewFlag ); + void ReportChinesePopupEventL( TBool aChinesePopupOpen ); + +public: // new utility methods + + /** + * Replaces the cursor selection with the identified text. + * + * @param aInsertPos The position at which text will be inserted. + * @param aText The text to insert. + * @param aDelete The cursor-selected text that will be replaced by @c + * aText. + */ + IMPORT_C void InsertDeleteCharsL(TInt aInsertPos, + const TDesC& aText, + const TCursorSelection& aDelete); + + /** + * Sets non-printing characters?visibility. + * + * @param aVisibility Non-printing characters?visibility. + */ + IMPORT_C void SetNonPrintingCharsVisibility(TNonPrintingCharVisibility + aVisibility); + + /** + * Sets non-printing characters?visibility. + * + * @return Non-printing characters?visibility. + */ + IMPORT_C TNonPrintingCharVisibility NonPrintingCharsVisibility() const; + +public: // new Avkon wrap interface + + /** + * Sets the @c EAvkonEditor flag. + * + * @param aAvkonWrapIsOn If @c ETrue @c EAvkonEditor flag is set. + */ + IMPORT_C void SetAvkonWrap(TBool aAvkonWrapIsOn); + +public: // Avkon editor extensions + + /** + * Sets default case for the editor. The case is used when the editor + * is focused first time. Available case flags from @c uikon.hrh + * are @c EAknEditorUpperCase, @c EAknEditorLowerCase and + * @c EAknEditorTextCase. @c EAknEditorTextCase is used if the initial + * case is not set from EDWIN resource default_case or with this API. + * + * @param aCase Initial case to be used in the editor. + */ + IMPORT_C void SetAknEditorCase(TInt aCase); + + /** + * Sets permitted cases for the editor. + * Possible flags from @c uikon.hrh are @c EAknEditorAllCaseModes, + * @c EAknEditorUpperCase, @c EAknEditorLowerCase and + * @c EAknEditorTextCase. @c EAknEditorAllCaseModes is used if the value + * is not set from EDWIN resource allowed_case_modes or with this API. + * + * @param aPermittedCaseModes Case modes that are available in the editor. + */ + IMPORT_C void SetAknEditorPermittedCaseModes(TInt aPermittedCaseModes); + + /** + * Sets number mode key mapping for '*' and '#' keys. The key mapping is + * used in editors when numeric input mode is used. Key mapping characters + * for '*' key are shown on special character table if also text input + * modes are allowed in the editor but the current input mode is numeric + * mode. @c EAknEditorStandardNumberModeKeymap is used in editors that + * allow only numeric input if the mapping is not set from EDWIN resource + * @c numeric_keymap or with this API. + * @c EAknEditorAlphanumericNumberModeKeymap is used as default if the + * editor allows also text input mode. + * + * @param aNumericKeymap Key mapping used in an editor with number input + * mode. + */ + IMPORT_C void SetAknEditorNumericKeymap(TAknEditorNumericKeymap + aNumericKeymap); + + /** + * Sets default input mode for the editor. The input mode is used when + * the editor is focused first time. + * @c EAknEditorTextInputMode is used if the initial input mode is not set + * from EDWIN resource default_input_mode or with this API. + * + * @param aInputMode Initial input mode to be used in the editor. + */ + IMPORT_C void SetAknEditorInputMode(TInt aInputMode); + + /** + * Sets allowed input modes for the editor. + * All input modes are allowed (@c EAknEditorAllInputModes) if the value + * is not set from EDWIN resource @c allowed_input_modes or with this API. + * + * @param aInputModes Input modes that are allowed in the editor. + */ + IMPORT_C void SetAknEditorAllowedInputModes(TInt aInputModes); + + /** + * Sets editor specific special character table. + * + * @param aSCTResId Special character table dialog resource. + */ + IMPORT_C void SetAknEditorSpecialCharacterTable(TInt aSCTResId); + + /** + * Sets initial editor flags for the editor. + * This method can be used also to update editor flags after the editor is + * focused. FEP is automatically notified of the updated editor flags. + * + * @param aFlags Avkon editor flags for the editor. + */ + IMPORT_C void SetAknEditorFlags(TInt aFlags); + + /** + * Enables or disables CCPU interface provided functionalities + * (cut, copy, paste and undo). + * + * @param aSupport CCPU support enabled if @c ETrue. + */ + IMPORT_C void EnableCcpuSupportL(TBool aSupport); + + /** + * Updates editor input mode. FEP is automatically notified of the + * new input mode in editor state and FEP takes new input mode to use + * immediatelly. Current inline editing is reset. + * This method should not be used for setting initial input mode for the + * editor. Use @c SetAknEditorInputMode() method instead for setting + * initial input mode. + * + * @param aInputMode New input mode for the editor. + */ + IMPORT_C void SetAknEditorCurrentInputMode(TInt aInputMode); + + /** + * Returns the input mode that has been saved to editor state. + * + * @since S60 2.6 + * @return Input Mode that is saved to editor state. + */ + IMPORT_C TInt AknEditorCurrentInputMode(); + + /** + * Updates editor case. FEP is automatically notified of the + * case change in editor state and FEP takes new case to use immediately. + * Available case flags from @c uikon.hrh are @c EAknEditorUpperCase, + * @c EAknEditorLowerCase and @c EAknEditorTextCase. + * This method should not be used to set initial case for the editor. + * Use @c SetAknEditorCase() method instead for setting initial case. + * + * @param aCase New case for the editor. + */ + IMPORT_C void SetAknEditorCurrentCase(TInt aCase); + + /** + * Sets new local input language for the editor. Global input language + * changes have not effect for the input language but the user can still + * change the input language from the edit menu. + * + * @param aLanguage Editor local input language. + */ + IMPORT_C void SetAknEditorLocalLanguage(TLanguage aLanguage); + + /** + * This call causes FEP to reset current editing state and + * new editing state is fetched from @c CAknEdwinState object. + */ + IMPORT_C void NotifyEditorStateObserverOfStateChangeL(); + + /** + * Used for suppressing all editor's background drawing. This is + * intended for internal use. + * + * Note that when this is set, the background is not drawn with skin + * nor cleared, so the background MUST be drawn by the parent control + * every time the editor changes. + * + * @param aSuppress If ETrue, suppress background drawing + */ + IMPORT_C void SetSuppressBackgroundDrawing( TBool aSuppress ); + + /** + * Tests if the background drawing is suppressed. + * + * @return ETrue if the background drawing is suppressed + */ + IMPORT_C TBool IsBackgroundDrawingSuppressed() const; + + /** + * Used to prevent partial text lines from being drawn. + * The client is responsible for giving a sane value. An empty + * rect disables this feature. This is intended for internal use. + * + * @param aRect The rect which contains text lines to be drawn + */ + IMPORT_C void SetTextLinesRect( const TRect& aRect ); + + /** + * Used to determine which area is used for scrolling + */ + IMPORT_C void SetScrollRect( const TRect & aRect ); + + /** + * Gets the rectangle set for drawing only full lines. In case + * the feature is disabled, this returns an empty rect. + * This is intended for internal use. + * + * @return The rect which contains text lines to be drawn + */ + IMPORT_C TRect GetTextLinesRect() const; + + /** + * Used to control cursor visibility + */ + IMPORT_C void SetCursorVisible(TBool aVisible); +public: + + // These methods have been added for use with Avkon to set maximum + // editor heights. + /** + * Sets editor's maximum height in lines. + * + * @param aLines Maximum height in lines. + */ + IMPORT_C void SetMaximumHeightInLines(TInt aLines); + + /** + * Gets editor maximum height in lines. + * + * @return Maximum height in lines. + */ + IMPORT_C TInt MaximumHeightInLines() const; + +public: // From MEikCcpuEditor + + /** + * Tests whether the editor is focused. + * + * @return If editor is focused, @c ETrue is returned. + */ + IMPORT_C TBool CcpuIsFocused() const; + + /** + * Tests whether the selected text can be cut. + * + * @return @c ETrue if it is possible to cut the selected text. + */ + IMPORT_C TBool CcpuCanCut() const; + + /** + * Cuts selected text. + */ + IMPORT_C void CcpuCutL(); + + /** + * Tests whether the selected text can be copied. + * + * @return @c ETrue if it is possible to copy the selected text. + */ + IMPORT_C TBool CcpuCanCopy() const; + + /** + * Copies selected text. + */ + IMPORT_C void CcpuCopyL(); + + /** + * Tests whether text can be pasted from the clipboard. + * + * @return @c ETrue if it is possible to paste the clipboard text. + */ + IMPORT_C TBool CcpuCanPaste() const; + + /** + * Pastes text from the clipboard to the editor. + */ + IMPORT_C void CcpuPasteL(); + + /** + * Tests is it possible to undo previous operation. + * + * @return @c ETrue if it is possible to undo previous operation. + */ + IMPORT_C TBool CcpuCanUndo() const; + + /** + * Undoes the most recent text operation when the Edwin supports this + * feature and when the undo store is not empty + */ + IMPORT_C void CcpuUndoL(); + + /** + * Gets edwin's flags from @c CAknEdwinState. + * + * @return The control's flags. + */ + IMPORT_C TInt AknEdwinFlags() const; + + +public: // Internal to Symbian + + // the following methods are deprecated and will be removed in a future + // release + /** + * Allocates memory for the Edwin text view. + */ + IMPORT_C void CreateTextViewL(); + + /** + * Gets Edwin text view. + * + * @return Pointer to the Edwin text view. + */ + IMPORT_C CTextView* TextView() const; + + /** + * Gets Edwins text layout. + * + * @return Pointer to the text layout. + */ + IMPORT_C CTextLayout* TextLayout() const; + + /** + * Sets undo buffer for the Edwin. + * + * @param aSelection The current selection. + * @return @c ETrue if buffer was set. + */ + IMPORT_C TBool SetUndoBufferL(const TCursorSelection& aSelection); + + /** + * Sets new undoable text to the undo buffer. + * + * @param aSelection The current selection. + */ + IMPORT_C void SetUndoableText(const TCursorSelection& aSelection); + + /** + * Gets the editor state. + * + * @return Pointer to editor state object. + */ + CAknEdwinState* EditorState() const; + + /** + * Sets maximum length for the editor. + * + * @param aLength Maximum length for the editor. + */ + inline void SetMaxLength(TInt aLength); + + /** + * Gets the editor maximum length. + * + * @return The editor maximum length + */ + inline TInt MaxLength() const; + +public: + + // added to get access to user flags without a get/set for every different + // flag. + /** + * Adds user flags. + * See @c TFlags. + * + * @param aFlag Flags to add. + */ + IMPORT_C void AddFlagToUserFlags(TUint32 aFlag); + + /** + * Removes user flags. + * See @c TFlags. + * + * @param aFlag Flags to remove. + */ + IMPORT_C void RemoveFlagFromUserFlags(TUint32 aFlag); + + /** + * Gets user flags. + * See @c TFlags. + * + * @return The user flags. + */ + IMPORT_C TUint32 UserFlags() const ; + +public: + + /** + * Sets the character format layer for the editor. Ownership of the + * CCharFormatLayer is transferred. + * + * @param aCharFormatLayer Pointer to the character format layer object. + */ + IMPORT_C void SetCharFormatLayer(CCharFormatLayer* aCharFormatLayer); + + /** + * Sets the paragraph format layer for the editor. Ownership of the + * CParaFormatLayer is transferred. + * + * @param aParaFormatLayer Pointer to the paragraph format layer object. + */ + IMPORT_C void SetParaFormatLayer(CParaFormatLayer* aParaFormatLayer); + + +public: // Skins support + + /** + * Sets within in the editor an externally owned Skins background control + * context. This background control context will then be used by the editor + * to draw background. + * + * If this API is not called, then the editor IS skin enabled, (that is + * @c CEikEdwins are skin enabled by default) but it will try to find a + * control context with which to perform background drawing from the + * Control Environment, via the Object Provider. + * + * Setting this control context to NULL will have the effect of turning off + * background skinning. + * + * @param aContext Control context to store. Not owned. Can be NULL. + */ + IMPORT_C void SetSkinBackgroundControlContextL( MAknsControlContext* + aContext ); + + /** + * Access to Skins background control context that is potentially being + * used by the Editor. + * + * This API will first check to see if an control context has been set by + * API, and if so, return that. If the background control context has been + * set to NULL by API, then it will return NULL. If the background control + * context has never been set by API, then this returns the control context + * (if one exists) that the object obtains from Object Provider. + * + * @return Pointer to control context potentially in + * use, or NULL. + */ + MAknsControlContext* SkinBackgroundControlContext() const; + + /** + * Access to disposition of the editor to perform Skinning. This does not + * take into account whether the application is skin enabled or whether the + * environment is providing a background control context. It is only a + * function of whether editor's (default) disposition to skin has been + * countered by calls on the editor API. + * + * @return @c EFalse if SetSkinBackgroundControlContextL has been + * called with NULL in its most recent call. + */ + TBool SkinEnabled() const; + + /** + * Stores the alignment value for an editor. + * + * @param aAlignment Editor alignment to be stored - must be supplied as + * one of the values in Avkon editor alignment enum i.e.: + * EAknEditorAlignCenter, + * EAknEditorAlignLeft, + * EAknEditorAlignRight, + * EAknEditorAlignBidi + */ + IMPORT_C void SetAlignment(TInt aAlignment); + +public: // Pictograph support + + /** + * Redraws text view. Used for pictograph animations. + */ + void DrawTextView() const; + + /** + * Sets the callback, which the editor calls after having redrawn itself + * for animated pictographs. @c CEikCaptionedControl uses it to draw the + * highlight frame on top of the editor. + * + * @since S60 2.6 + * @param aCallBack The callback. + */ + IMPORT_C void SetPictographAnimationCallBack( TCallBack& aCallBack ); + + /** + * Returns pictograph animation callback. If it is not set, the function + * pointer is NULL. + * + * @return Pictograph animation callback + */ + const TCallBack& PictographAnimationCallBack() const; + + /** + * This method sets the upper limit of full document formatting. + * + * At construction, the mode is full document formatting, where the text + * formatter processes the whole document to determine its layout. + * + * When the text content is set, or when user input causes the length of + * text to exceed this value, the formatting mode switches to "Band" + * formatting, where the text formatter attempts to format as little as + * possible - optimally just the visible screen. + * + * A lower limit is calculated from the passed-in value, by the subtraction + * of a constant. When the text becomes smaller than this lower limit, the + * formatting switches to full document formatting. + * + * Internally-imposed limits prevent the client setting too small a value + * for proper operation of the text formatting. + * + * If this method is not called, the upper and lower limts are set to a + * large default values. + * + * Access to the actual limits is available via the methods + * @c UpperFullFormattingLength() and @c LowerPartialFormattingLength(). + * + * @since 3.0 + * @param aUpperFullFormattingLimit The upper limit of full document + * formatting. + */ + IMPORT_C void SetUpperFullFormattingLength( TInt aUpperFullFormattingLimit ); + + /** + * Can be called to inhibit redrawing of the editor when NotifyNewFormatL() + * is called. + * + * @param aEnabled If ETrue, inhibit redrawing when notified of + * new format from now on. + */ + IMPORT_C void SetSuppressNotifyDraw( TBool aEnabled ); + + /** + * Can be called to inhibit formatting of the editor. Care is required to ensure that + * the necessary reformatting is carried out later on if this API is used. + * + * Note: When called with EFalse, it does not automatically trigger reformatting. + * + * @since 3.1 + * @param aSuppressed If ETrue, inhibit formatting from now on, if EFalse, + * re-enable formatting from now on. + */ + IMPORT_C void SetSuppressFormatting( TBool aSuppressed ); + + /** + * Enables kinetic scrolling in editor. + * + * Note that when kinetic scrolling is enabled, it is + * no longer possible to disable it with this function. + * + * @since S60 v5.2 + * @param aEnable ETrue if kinetic scrolling should be enabled. + */ + IMPORT_C void EnableKineticScrollingL( TBool aEnable ); + + /** + * Enables kinetic scrolling in editor with external CAknPhysics instance. + * + * Note that when kinetic scrolling is enabled, it is + * no longer possible to disable it with this function. + * + * @since S60 v5.2 + * @param aPhysics Pointer to external CAknPhysics instance. + */ + IMPORT_C void EnableKineticScrollingL( CAknPhysics* aPhysics ); + +public: + void EnableSmileySupportL( TBool aEnableSmiley ); + TBool IsSmileyEnabled() const; + void DrawSmileyInTextL( RRegion& rgn, const TRect& aDrawRect, + CBitmapContext& aGc, CFont& aFont, const TDesC& aText, const TPoint& aPt ); + void ConvertVisibleTextForSmileyL( TBool aTextToCode ); + TBool AdjustCursorForSmileyL( TInt aOldCursor, TCursorSelection& aSelect ); + TRect AdjustDrawRectForSmiley( const TRect& aRect ) const; + HBufC* ExtractTextLC( TCursorSelection aSelect ); + void ConvertSmileyIconToTextL( TInt aStartPos, TDes& aText ); + +private: + void ConvertTextForSmileyL( TCursorSelection aSelect, + TBool aTextToCode, TBool aRedraw = ETrue ); + void TrimText( TDes& aText ); + TCursorSelection GetVisibleTextRangeL(); + void ExtendedRangeForSmiley( TCursorSelection& aSelect ); + TBool ConvertSmileyForDeleteL( TInt aDocPos, TBool aBackSpace ); + void ConvertSmileyForDeleteL( const TCursorSelection &aSelect ); + TBool AdjustCursorPosByMovementL( TCursorPosition::TMovementType aMovement, + TBool aSelect ); + void HandleSelectionForSmiley( TCursorSelection aSelect ); + +protected: + + /** + * Specifies the end points of the editable area. + */ + enum TEnd + { + /** The start of the editable area. */ + EStart, + + /** The end of the editable area. */ + EEnd + }; + + /** + * Specifies the chunk size as either a word, or a paragraph. + */ + enum TChunkSize + { + /** A word. */ + EChunkWord, + + /** A paragraph. */ + EChunkPara + }; + + /** + * Specifies the chunk size as either a word, or a paragraph. + */ + enum TEikEdwinFlags // Internal flags + { + /** Rich text editor used. */ + ERichText =0x00000001, + + /** For double item dragging. */ + EDragDouble =0x00000002, + + /** + * If set, indicates the pointer being pressed inside the + * editor rectangle. + */ + ELeftDownInViewRect =0x00000004, + + /** Used to calculate initial width. */ + ENumericCharacters =0x00000008, + + /** Edwin has one line and is not resizable. */ + EHasOneLineOnly =0x00000010, + + /** + * Custom formatter is installed to find and format phone numbers + * (@c CEikRichTextEditor only). + */ + EPhoneNumberGrouping = 0x00000020, + ESuppressNotifyDraw = 0x00000040, + ESuppressFormatting = 0x00000080, // Suppresses calls to formatting + ESkipBackgroundDrawer = 0x00000100 + /* NOTE : If you want to add new flags here please be carefull. There are other + flags are defined as + enum + { // internal flags + EWysiwygOn = 0x00000200, + EUnderOneScreenFormattedText = 0x00000400, + EPictureDelimits = 0x00000800, + EPunctuationDelimits = 0x00001000, + EPasteFromIrStore = 0x00002000, + ELockScrollBarState = 0x00004000, + EOnReformatting = 0x00008000 + }; + */ + }; + +protected: // from MEditObserver + + /** + * From @c MEditObserver. + * + * Observer function called by the @c CRichText object when the object is + * edited to give notification of changes to its text buffer. In this way, + * the control knows how the text object has changed and can reformat and + * redraw the text object appropriately. + * + * @param aStartEdit The start position of the edit. + * @param aEditLength The number of characters added or, if negative, + * deleted after this position. + */ + IMPORT_C void EditObserver(TInt aStartEdit,TInt aEditLength); + +protected: + + /** + * Draws the visible text and the cursor for DrawL(), but does not draw + * the border. The @c DrawL() function is trapped to handle problems due + * to insufficient resources being available. + * + * @param aRect Rectangle in which to draw. + */ + IMPORT_C void TrappedDraw(const TRect& aRect) const; + + /** + * Draws the visible text and the cursor. + */ + IMPORT_C void DrawContents(); + + /** + * Completes the second-phase construction of a @c CEikEdwin object. This + * protected function is called by @c ConstructL() and + * @c ConstructFromResourceL() after the Edwin’s size, flags and text + * limit have been set. Derived classes should call either this function + * or @c CEikEdwin’s @c ConstructL() or @c ConstructFromResourceL() + * functions during their construction before initialising their own + * members. + */ + IMPORT_C void BaseConstructL(); + + /** + * Formats all the text in the text view. Called by several functions, for + * example by @c CEikEdwin::HandleTextChangedL() and + * @c CEikEdwin::SetTextL(). + */ + IMPORT_C void FormatTextL(); + + /** + * Deletes the text under the cursor selection, also cancelling the + * selection. This function asks the user to confirm this action if + * aPromptConfirmation is ETrue. + * + * @param[out] aChanged On return, @c ETrue if the text was changed. + * @param[in] aIsBackSpace ETrue if this is in response to backspace being + * pressed. Determines whether character formatting is preserved + * or not. Default value is @c EFalse. + * @param[in] aPromptConfirmation Optional. @c ETrue to ask the user to + * confirm this action. Default value is @c ETrue. + * @return The cursor position in the text after deletion. + */ + IMPORT_C TInt DeleteHighlightL(TBool& aChanged, + TBool aIsBackSpace=EFalse, + TBool aPromptConfirmation=ETrue); + + /** + * Confirms whether the deletion of the user’s selection is required. + * + * If the user’s selection is less than @c KBlockDeleteWarningSize and does + * not contain a picture, this function returns @c ETrue. + * + * If the user’s selection is greater than @c KBlockDeleteWarningSize or + * contains a picture, this function asks the user to confirm deletion of + * their selection and then returns the user’s response. + * + * @return @c ETrue. + */ + IMPORT_C TBool OkToDeleteSelectionL(); + + /** + * Deletes the cursor’s selection. If no selection is made, this function + * deletes only one character. The argument @c aIsBackSpace determines + * whether to preserve the character formatting or not. + * + * @param[out] aChanged On return, @c ETrue if the text was changed. + * @param[in] aSelection The cursor selection describing the position to be + * deleted. + * @param[in] aIsBackSpace @c ETrue if this in response to backspace being + * pressed. Determines whether character formatting is preserved + * or not. + * @param[in] aAllowUndo @c ETrue if the user is permitted to undo this + * change. + */ + IMPORT_C void DeleteL(TBool& aChanged, + const TCursorSelection& aSelection, + TBool aIsBackSpace=EFalse, + TBool aAllowUndo=ETrue); + + /** + * Handles errors that occur when handling a change in Edwin’s size. Calls + * @c CEikonEnv::NotifyIdleErrorWhileRedrawing(). + */ + IMPORT_C void TrappedSizeChanged(); + + /** + * Handles a change in Edwin’s size. This function accounts for text wrap + * settings and whether the Edwin is ready to be redrawn and also calls + * functions to reformat text and to update the Edwin’s scroll bars. + */ + IMPORT_C void HandleSizeChangedL(); + + /** + * Cancels the selection and any FEP composition text. This function then + * repositions the cursor at the specified end of the currently selected + * text. + * + * @param aEndOfSelectionToLeaveCursor The end of the current selection at + * which the cursor is repositioned. + */ + IMPORT_C void CancelSelectionL(TEnd aEndOfSelectionToLeaveCursor); + + /** + * Moves the cursor to the beginning of the next word or paragraph. This + * function cancels any front end processing transaction currently in + * progress for the Edwin. + * + * @param aSelect If @c ETrue the chunk is selected, otherwise @c EFalse. + * @param aChunkSize The chunk size, this can be either a word or a + * paragraph. See @c TChunkSize enum. + * @param aEndScanningTowards Which direction to scan towards, the start + * or the end of the document. + */ + IMPORT_C void MoveCursorToChunkStartL(TBool aSelect, + TChunkSize aChunkSize, + TEnd aEndScanningTowards); + + /** + * Cancels the insertion of a character format. This can be used for rich + * text only. + */ + IMPORT_C void CancelInsertCharFormat(); + + /** + * Copies the contents of the cursor selection onto the clipboard. + */ + IMPORT_C void PlaceDataOnClipboardL(); + + /** + * Reports an Edwin event of the specified type. The Edwin event is passed + * first to the Edwin observer and then to the list of observers, even if + * the first Edwin observer is not set. If the Edwin has a custom drawer, + * and the event is of type @c EEventFormatChanged, the event is passed to + * the custom drawer. If the Edwin has an observer the event is passed to + * that observer. If no observer is set for the Edwin, this function passes + * the event to each observer in the observer list. + * + * @param aEventType The type of event to report. + */ + IMPORT_C void ReportEdwinEventL(MEikEdwinObserver::TEdwinEvent aEventType); + + /** + * Sets margin widths and line cursor width. + */ + IMPORT_C void SetLineCursorDetailsL(); + + /** + * Replaces the current Edwin text. + * + * @param aInText Text with which the current text is replaced. + * @param aOutText On return, the replaced text. + */ + IMPORT_C virtual void CopyDocumentContentL(CGlobalText& aInText, + CGlobalText& aOutText); + + /** + * Displays an information message to indicate that the specified text + * could not be found. The information message is constructed from + * @c R_EIK_TBUF_CANNOT_FIND_TEXT. + * + * @param aFindText The text that could not be found. + */ + IMPORT_C void DisplayFindTextNotFound(TDes& aFindText); + + /** + * Not implemented. + * + * @param aStartPos Not used. + * @param aLength Not used. + */ + IMPORT_C virtual void HandleTextPastedL(TInt aStartPos,TInt& aLength); + + /** + * Creates a new @c CLafEdwinCustomDrawBase instance. + * + * @return Pointer to new custom @c CLafEdwinCustomDrawBase object. + */ + IMPORT_C virtual CLafEdwinCustomDrawBase* CreateCustomDrawL(); + + // Avkon editor extensions + /** + * Used in @c ConstructFromResourceL(). Sets Avkon editor properties. + * + * @param aReader A reader positioned for reading from an EDWIN resource. + */ + IMPORT_C void ReadAknResourceL(TResourceReader& aReader); + +protected: // Internal to Symbian + + /** + * Creates new text layout. + * + * @param aLayDoc Pointer to the @c MLayDoc implementation that is the + * source of the text and formatting information. + */ + IMPORT_C void CreateLayoutL(MLayDoc* aLayDoc); + + /** + * Creates new instance of @c CGlobalText and text layout based on it. + * + * @param aParaFormatLayer Paragraph format layer pointer for + * @c CGlobalText constructor. + * @param aCharFormatLayer Character format layer pointer for + * @c CGlobalText constructor. + */ + IMPORT_C void CreateTextAndLayoutL(CParaFormatLayer* aParaFormatLayer, + CCharFormatLayer* aCharFormatLayer); + + /** + * Checks that is Edwin's extension created. If not, it will be created. + * + * @leave KErrNoMemory If the Edwin FEP support pointer is NULL. + */ + IMPORT_C void CheckEdwinExtensionL(); + + /** + * Gets Edwin's extension. + * + * @return Pointer to Edwin's extension. + */ + IMPORT_C CEikEdwinExtension* EdwinExtension(); +private: + // NOTE : the follow enume and the enum TEikEdwinFlags are both used for iEdwinInternalFlags + // it is very easy to conflict !!! So if you want add new flag please check if it has been + // declared in enum TEikEdwinFlags + enum + { // internal flags + EWysiwygOn = 0x00000200, + EUnderOneScreenFormattedText = 0x00000400, + EPictureDelimits = 0x00000800, + EPunctuationDelimits = 0x00001000, + EPasteFromIrStore = 0x00002000, + ELockScrollBarState = 0x00004000, + EOnReformatting = 0x00008000 + }; + +private: // from CCoeControl + + IMPORT_C void SizeChanged(); + IMPORT_C TInt CountComponentControls() const; + IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const; + IMPORT_C void Reserved_2(); + +private: + + IMPORT_C virtual void Reserved_3(); + IMPORT_C virtual void NotifyInvalidOperationOnReadOnlyL(); + IMPORT_C CEikScrollBarFrame* CreateScrollBarFrameL(TBool aPreAlloc); + void SetVirtualCursorStateL(TBool aIsFocused) const; + void SetHeightForNumOfLinesL(); + void ApplyAutoSelectionL(); + void SetScrollBarsL(); + void SetVertScrollBarModelByCharactersL(TEikScrollBarModel& aVertModel) const; + void RetrieveDataFromClipboardL(); + void SetCursorVisibilityL(TBool aEmphasis); + TBool OwnsScrollBars() const; + void CreateScrollBarFrameLayout(TEikScrollBarFrameLayout& aLayout) const; + void UpdateHorizScrollBarThumb(); + void UpdateVertScrollBarThumbL(); + void DoSetUndoBufferL(const TCursorSelection& aSelection); + void DoPasteFromStoreL(const CStreamStore& aStore,const CStreamDictionary& aDict); + void DoReplaceAllL(SEdwinFindModel* aModel,TBool& aTextFound,TBool& aReplaced); + void DeleteExtraParasL(TInt aStartPos,TInt aLength); + TInt LocateChar(TChar aChar,TInt aStartPos,TInt aLength); + TBool IsValidChar(TInt aChar) const; + TInt CalcMinimumHeightFromNumOfLinesL() const; + void CheckEdwinHeight(); + TBool IsNewHeightWithinMinimumAndMaximum(TInt aNewHeight) const; + void SetEdwinHeight(TInt aHeight); + void DoCreateCustomDrawL(); + void SetCursorSizeAndType(); + TKeyResponse DoOfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + void DoCcpuCanPasteL() const; + void DoReportEventL(MCoeControlObserver::TCoeEvent aEvent); + void CheckIfEdwinIsResizable(); + void SetKeyboardRepeatRate(TTimeIntervalMicroSeconds32 aKeyRepeatRate) const; + HBufC* GetAllowedCharsLC() const; + TInt CheckAllowedCharsL(const TDesC& aChars, CClipboard& aClipboard, TBool aRichText) const; + + TInt CursorWidth() const; + TFontSpec CursorFontSpec() const; + + void BuildEdwinFepSupport(); + void MakeCharFormatLayerMatchL(CCharFormatLayer* aCharFormatLayer); + void MakeParaFormatLayerMatchL(CParaFormatLayer* aParaFormatLayer); + void UpdateCache(TInt aId); + void DrawBackgroundAroundTextView( + CWindowGc& gc, + const TRect& aOuterRect, + const TRect& aInnerRect, + const TRgb& aBackgroundColor ) const; + TInt CurrentAlignment() const; + void DoAlignment(); + void NewParagraphL(); + TKeyResponse ScrollReadOnlyNoCursorDisplayL(TUint aKeyCode); + void ReplaceParaDelimitersL( TInt aStartPos, TInt aLength ); + TRect AdjustedViewRect() const; + void SetVKBStatus(); + void ScrollViewToCursorLineL(); + void PerformRecordedOperationL(); + void ScrollIfAtTopOrBottomL(); + void SetSelectionVisibilityL( TBool aIsVisable ); + + /** + * Sets scrollbars with kinetic scrolling. + */ + void SetKineticScrollingScrollBarsL(); + + /** + * Sets vertical scrollbar model with kinetic scrolling. + * + * @param aVertModel Vertical scrollbar model + */ + void SetKineticScrollingScrollBarModel( + TEikScrollBarModel& aVertModel ) const; + + /** + * Enables rate scrolling in editor. + * + * @param aEnable ETrue if rate scrolling should be enabled. + */ + void EnableRateScrolling( TBool aEnable ); + +private: + + void DrawFirstLineTextL() const; + CAknEdwinDrawingModifier* AknEdwinDrawingModifier(); + TBool EditorSupportsNeutralProtection() const; + + /** + * Main routine for neutral protection. This routine returns a boolean stating if there is a + * requirement for protection, but also returns the text that should replace the to-be-deleted text. + * + * @param aPosOfLosEndOfDelete index of the first character deleted + * @param aLengthToDelete length the text to be deleted + * @param aNewText neutral protection characters to replace the delete + * @param aForwardProtectionNeeded EFalse if only reverse protection needed; data valid only if + * method does not return EFalse. + * @return EFalse iff no deletion is to be performed + */ + TBool NeedsNeutralProtection( TInt aPosOfLowEndOfDelete, TInt aLengthToDelete, TDes& aNewText, TBool& aForwardProtectionNeeded ); + + /** + * Returns whether the character is strongly directional + * + * @param aChar character to be examined + * @param aRightToLeft This is valid upon return only if EFalse is not returned. + * Value is EFalse if the strong directionality is Left-to-right + * @return EFalse if the character is not strongly directional. + */ + TBool GetStrongDirectionality(TChar aChar, TBool& aRightToLeft ) const; + + /** + * Returns ETrue if the character at aPos is neutral + * + * @param aPos index in editor; must be a valid index + * @return EFalse iff the character is not neutral + */ + TBool CharIsNeutral( TInt aPos ) const; + + /** + * Looks through the passed descriptor, looking for a strongly directional character. + * Direction of search can be set. Search starts at the begining if searching forward; + * starts at the end if searching backwards. + * + * Search is carried out until a strong character is found or the end (or beginning) + * of the descriptor has been reached. + * + * @param aText Descriptor to search. + * @param aForward If EFalse, then search is backward (decreasing index) in logical buffer + * @param aIsRightToLeft Set to ETrue on return if first strong character found is RTL + * + * @return EFalse if no strong character was found. + */ + TBool GetExposedDirectionOfTextInDescriptor( const TDesC& aText, TBool aForward, TBool& aIsRightToLeft ) const; + + /** + * Looks through the editor's text starting at character aPos, looking for a + * strongly directional character. Direction of search can be set. + * Search is carried out until a strong character is found or the end (or beginning) + * of the editor text has been reached. + * + * @param aPos First character to look at + * @param aForward If EFalse, then search is backward (decreasing index) in logical buffer + * @param aIsRightToLeft Set to ETrue on return if first strong character found is RTL + * + * @return EFalse if no strong character was found. + */ + TBool GetExposedDirectionOfText( TInt aPos, TBool aForward, TBool& aIsRightToLeft ) const; + + /** + * Routine to perform the operation of replacing a selection with new text. + * This is intended for internal use. + * + * The current selection, if non-zero length is deleted, and replace with aNewText if non-zero length + * iTextView must be set. + * + * @param aNewText Replacement text. May be zero length. + * @param aCursorPosInNewText This is the position, relative to the beginning of the newtext, + * that you want the cursor to be at when the operation is complete + * @param aFormatHasChanged Set this to ETrue if you want the reformatting to start at + * the beginning of the paragraph. EFalse if just to reformat the line. + * This variable may also be set by the call to DeleteHighlight that this + * code executes, so it may be set to ETrue upon return, even if EFalse was + * passed. + */ + void ReplaceSelectionWithTextL( const TDesC& aNewText, + TInt aCursorPosInNewText, + TBool& aFormatHasChanged ); + + /** + * Returns EFalse iff ( phone number had only numeric input modes AND the keymap is a phone number + * type keymap ). + * Phone number type keymaps are: + * EAknEditorStandardNumberModeKeymap + * EAknEditorFixedDiallingNumberModeKeymap + * + * @return EFalse if the phone number will only contain a pure phone number + */ + TBool IsPurePhoneNumberEditor() const; + + /** + * Standard check on upper and lower formatting thresholds versus current textview formatting mode. + * + * @return EFalse iff the formatting mode does not need changing + */ + TBool NeedToChangeFormattingModeL() const; + + /** + * When Band formatting is started, this should be called to update the cached + * metrics used for the scroll bar calculations. + */ + void CalculateLineMetricsForBandFormattingL(); + + /** + * check the selection content is visible character or not + */ + TBool IsSelectionVisible(); + + +protected: // from MObjectProvider + + /** + * From @c MObjectProvider. + * + * Retrieves an object of the same type as that encapsulated in @c aId. + * + * This function is used to allow controls to ask their owners for access + * to other objects that they own. + * + * Other than in the case where NULL is returned, the object returned must + * be of the same object type - that is, the @c ETypeId member of the + * object pointed to by the pointer returned by this function must be equal + * to the @c iUid member of @c aId. + * + * @param aId An encapsulated object type ID. + * @return Encapsulates the pointer to the object provided. Note that the + * encapsulated pointer may be NULL. + */ + IMPORT_C TTypeUid::Ptr MopSupplyObject(TTypeUid aId); + +public: // new since 3.0 + + /** + * Sets skin id for text. + * + * @param aAknSkinIdForTextColor The skin id. + */ + IMPORT_C void SetTextSkinColorIdL(TInt aAknSkinIdForTextColor); + + /** + * Sets highlight style. + * + * @param aStyle The highlight style. + */ + IMPORT_C void SetHighlightStyleL(TAknsHighlightStyle aStyle); + + // for custom drawer, not exported + /** + * Gets skin id. + * + * @return The skin id. + */ + TInt SkinColorId() const; + + /** + * Gets highlight style. + * + * @return The highlight style. + */ + TAknsHighlightStyle HighlightStyle() const; + + /** + * Called to determine the background color to draw. It is not to be used if skinning is + * being used to draw the background. + * + * This API can be used two ways: + * + * i) If the caller has a default color to offer (to be used as + * a fallback if SetBackgroundColorL has not been called), then he should use the + * Input/Output parameter aConditionalColor, and ignore the return value. The output + * parameter will only be over-written by the set background color if SetBackgroundColorL + * has been called. + * + * ii) If the caller does not have a default color to offer, then he should pass in a dummy + * input parameter and use the return value. + * + * @param aConditionalColor Output parameter. Returns a color set by + * SetBackgroundColorL. It is unchanged if + * background color has not been set by SetBackgroundColorL + * @return TRgb for the color to be used for background. + */ + TRgb EditorBackgroundColor(TRgb& aConditionalColor) const; + +public: + /** + * Can be used by custom drawers to check if background drawing should be + * performed. This is meant to be used only if editor has + * MCoeControlBackground object attached. + * + * @return ETrue if custom drawer shouldn't draw background. + */ + TBool SkipBackgroundDrawer() const; + + /** + * Scrolls view by amount of pixels. + * Stops scrolling when beginning or end of content exceeded. + * This function should be used when scrolling starts from inside content + * (in other words in normal situation when begin- or end-border has not + * yet exceeded) + * + * @param aPixelsToScroll Amount of pixels to scroll + * @param aBorderExceeded returns ETrue if border was exceeded + * @param aRestOfPixels Amount of pixels not scrolled because border + * was exceeded + * + * @return Amount of scrolled pixels. + */ + TInt ScrollView( TInt aPixelsToScroll, TBool& aBorderExceeded, + TInt& aRestOfPixels ); + + /** + * Scrolls view by amount of pixels. + * + * This function should be used to scroll when we have already + * exceeded begin- or end-border (we are out of borders). + * This function supports scrolling so that there can be empty space + * above or below the editor content (used in bounce effect). + * Stops scrolling when we return back to inside borders. + * + * @param aPixelsToScroll Amount of pixels to scroll + * @param aEndOfBounce returns ETrue if content scrolled back + * to inside of borders + * @param aRestOfPixels Amount of pixels not scrolled + * + * @return Amount of scrolled pixels. + */ + TInt ScrollViewWithBounce( TInt aPixelsToScroll, TBool& aEndOfBounce, + TInt& aRestOfPixels ); + + /** + * Returns amount of pixels how much we are out of borders. + * + * @return Amount of pixels scrolled out of borders. + */ + TInt PixelsOutOfBorder() const; + + /** + * Handles scrollbar events with kinetic scrolling. + * + * @param aScrollBar The scrollbar. + */ + void HandleScrollEventWithPhysics( CEikScrollBar* aScrollBar ); + + /** + * If cursor is visible, disables it and stores cursor visibility info. + */ + void StoreCursorState(); + + /** + * Show cursor again if needed (based on stored cursor visibility info). + */ + void RestoreCursorState(); + + /** + * Returns ETrue if kinetic scrolling is enabled. + * + * @return ETrue if kinetic scrolling is enabled. + */ + TBool KineticScrollingEnabled() const; + + /** + * Draws background to the whole view area. Call with parameter value ETrue + * must be followed by a call with EFalse or otherwise window's redraw + * isn't ended properly and graphics context is not deactivated. + * + * @param aStart If true then window area occupied by editor's view is + * invalidated and redraw is began. Also graphics context is + * activated. EFalse ends the redraw and deactivates graphics + * context. + */ + void DrawViewBackground( TBool aStart ) const; + + /** + * Returns ETrue if editor content fits to view rect. + * + * @return ETrue if editor content fits to view rect. + */ + TBool ContentFitsToViewRect() const; + +protected: + + /** + * Edwin user flags. + */ + TUint32 iEdwinUserFlags; + + /** + * Internal Edwin flags. + */ + TUint32 iEdwinInternalFlags; + + /** + * Edwin's text content. + */ + CPlainText* iText; + +protected: // Internal to Symbian + + /** + * Edwin's text view. + */ + CTextView* iTextView; + + /** + * Edwin's text layout. + */ + CTextLayout* iLayout; + +protected: + + /** + * Maximum length ot the edwin. + */ + TInt iTextLimit; + + /** + * Number of lines in Edwin. + */ + TInt iNumberOfLines; + + /** + * Current zoom factor. + */ + MGraphicsDeviceMap* iZoomFactor; + + /** + * Cursor position. + */ + TInt iLastPointerDocPos; + + /** + * Edwin's margins. + */ + TMargins8 iMargins; + +private: + + friend class CEikEdwinFepSupport; + friend class CEikEdwinExtension; + // added this class to allow additional data members without breaking BC + CEikEdwinExtension* iEdwinExtension; // replaced iSetScrollBar + CEikScrollBarFrame* iSBFrame; + MEikEdwinObserver* iEdwinObserver; + CArrayPtr* iObserverArray; + CEikEdwinFepSupport* iEdwinFepSupport; + CUndoBuffer* iUndoStore; + TInt iAvgLinesInViewRect; + TInt iAvgCharsPerLine; + TInt iRightWrapGutter; + TInt iLayoutWidth; + MEikEdwinSizeObserver* iEdwinSizeObserver; + TInt iMinimumHeight; + TInt iMaximumHeight; +/* +iMaximumHeightInLines +--------------------- +This is simply a holder for the number, used to simplify some Avkon LAF requirements. +The viewable region of an edwin is actually measured in pixels, However, if certain LAF +requirements are enforced (that the view region has to be smaller than the number of +lines viewable * the baseline separation (in pixels)) some undesired scrolling effects +occur. + + +That is to say, by simply setting iMaximumHeightInLines, this will not affect +the actual maximum height of the edwin. To do this, you must set the iMaximumHeight + +One of the use cases of this member variable is for AknLayoutUtils::LayoutEdwin. +That method uses iMaximumHeightInLines along with the baseline separation, to set +the iMaximumHeight. + +The general formula is very simple, to remove unneeded scrolling. +iMaximumHeight=baselineSeparation*iMaximumNumberOfLines + +If you cannot allocate sufficient space to the edwin, to permit so much viewable region +then the method AlterViewRect can be called on the TextView() component. This will introduce +a clipping rectangle, which allows blank space required by the edwin layout component +to not be shown. +*/ + TInt iMaximumHeightInLines; + CLafEdwinCustomDrawBase* iCustomDrawer; + TInt iLastPointerAnchorPos; + CAknCcpuSupport* iCcpuSupport; + CCharFormatLayer* iCharFormatLayer; + CParaFormatLayer* iParaFormatLayer; + TInt iSpare_1; + TInt iSpare_2; + }; + + +inline CEikScrollBarFrame* CEikEdwin::CreatePreAllocatedScrollBarFrameL() + { return CreateScrollBarFrameL(ETrue);} +inline CEikScrollBarFrame* CEikEdwin::ScrollBarFrame() + { return ((CEikScrollBarFrame* const)iSBFrame); } +inline TInt CEikEdwin::AvgLinesInViewRect() const + { return iAvgLinesInViewRect; } +inline TInt CEikEdwin::AvgCharsPerLine() const + { return iAvgCharsPerLine;} +inline void CEikEdwin::SetAvgLinesInViewRect(TInt aAvgLines) + { iAvgLinesInViewRect=aAvgLines; } +inline void CEikEdwin::SetAvgCharsPerLine(TInt aAvgChars) + { iAvgCharsPerLine=aAvgChars; } + +inline void CEikEdwin::SetMaxLength(TInt aLength ) + { SetTextLimit(aLength); } +inline TInt CEikEdwin::MaxLength() const + { return iTextLimit; } + +#endif