C++ default constructor.

Creates a new Edwin, FEP support for the new editor will not be present if there is insufficient memory.

Constructor.

Creates a new 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.

Destructor.

Deletes objects and frees resources owned by this object. The Edwin s editable text is freed if the EKeepDocument flag is not set.

From CCoeControl.

Sets the Edwin as ready for drawing.

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 SetEdwinObserver.

Add an observer of standard edwin events. May be called any number of times and is independant of calls to SetEdwinObserver.

Adds user flags. See TFlags.

Returns the input mode that has been saved to editor state.

Gets editor flags from the editor.

Gets edwin's flags from CAknEdwinState.

Gets the average number of characters on a line.

Gets the average number of lines shown in Edwin s view.

Completes the second-phase construction of a CEikEdwin object. This protected function is called by ConstructL() and ConstructFromResourceL() after the Edwin s size, flags and text limit have been set. Derived classes should call either this function or CEikEdwin s ConstructL() or ConstructFromResourceL() functions during their construction before initialising their own members.

When Band formatting is started, this should be called to update the cached metrics used for the scroll bar calculations.

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 CFont::MaxNormalCharWidthInPixels() is used.

If the EWidthInPixels flag has been set, the aWidthInChars argument is measured in pixels, not characters.

Tests whether an undo is possible. Returns ETrue only if the undo store is available to Edwin.

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 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.

Cancels the insertion of a character format. This can be used for rich text only.

Cancels the selection and any FEP composition text. This function then repositions the cursor at the specified end of the currently selected text.

Tests whether the selected text can be copied.

Tests whether the selected text can be cut.

Tests whether text can be pasted from the clipboard.

Tests is it possible to undo previous operation.

Copies selected text.

Cuts selected text.

Tests whether the editor is focused.

Pastes text from the clipboard to the editor.

Undoes the most recent text operation when the Edwin supports this feature and when the undo store is not empty

Returns ETrue if the character at aPos is neutral

Checks that is Edwin's extension created. If not, it will be created.

Determines whether the document being edited is read only. Displays a message with CEikonEnv::InfoMsg() if the document is set as read-only.

Removes unwanted pictures. If EAllowPictures has been set, returns immediately. Otherwise, this function checks the document text between two bounds and removes all pictures in that range.

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.

Removes the selection and any composition text. The cursor position is unaffected. If there is no selected region, this function has no effect.

Deletes the undo store.

Handles cut, copy and paste commands. This function also reports a change of state of the control to the observer when necessary.

From CCoeControl.

Completes the construction of a new Edwin. This function initialises the heap-stored members from an EDWIN resource.

Handles Symbian 2nd phase construction. Completes construction of a new Edwin, initialising its heap-stored members from the supplied arguments.

Returns ETrue if editor content fits to view rect.

Replaces the current Edwin text.

Copies the highlighted text into a stream store.

Counts and returns the number of words in the document.

Creates a new CLafEdwinCustomDrawBase instance.

Creates new text layout.

Creates a pre-allocated scroll bar frame.

Creates the Edwin scroll bar frame with no pre-allocation of memory for scroll bars.

Creates new instance of CGlobalText and text layout based on it.

Allocates memory for the Edwin text view.

Gets the cursor s position within the document.

Deletes the text under the cursor selection, also cancelling the selection. This function asks the user to confirm this action if aPromptConfirmation is ETrue.

Deletes the cursor s selection. If no selection is made, this function deletes only one character. The argument aIsBackSpace determines whether to preserve the character formatting or not.

Displays an information message to indicate that the specified text could not be found. The information message is constructed from R_EIK_TBUF_CANNOT_FIND_TEXT.

From CCoeControl.

Draws the control on request.

This routine performs draws in the area around the text view. Most of the work is to drive the custom drawer if present.

Draws the visible text and the cursor.

Redraws text view. Used for pictograph animations.

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.

From MEditObserver.

Observer function called by the 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.

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.

Gets the editor state.

Gets Edwin's extension.

Enables or disables CCPU interface provided functionalities (cut, copy, paste and undo).

Enables kinetic scrolling in editor.

Note that when kinetic scrolling is enabled, it is no longer possible to disable it with this function.

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.

Enables rate scrolling in editor.

From CAknControl

Gets true if a substring is present in the text being edited before or after the cursor position. If aFindText is NULL, then the current word or selection will be searched for again.

Gets the cursor position of the matching text in the document. The search starts from aPos. If aFindText is NULL, then the current word or selection will be searched for. If the substring cannot be found, this function returns KErrNotFound.

From CCoeControl.

Responds to focus-changed events.

Forces the scrollbars to update now; this is a synchronous function.

Formats all the text in the text view. Called by several functions, for example by CEikEdwin::HandleTextChangedL() and CEikEdwin::SetTextL().

From 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 aColorUseList.

Gets the list of logical colors employed in the drawing of the control, paired with an explanation of how they are used. Appends the list to aColorUseList.

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.

Start at pos and scan for strong characters. Stop at paragraph boundaries. Maximum of KMaxSearch of about 1 line...

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.

Gets the current word or selection and searches for it. This function is called by FindL() and FindTextL() when no text to search for is given.

Returns whether the character is strongly directional

Copies the entire document s content into a descriptor. It is the caller's responsibility to provide a large enough buffer.

Gets a new buffer containing a copy of the whole text document.

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.

Gets the start position and the length of the word in which the specified document position is located.

From CCoeControl.

Handles pointer events.

From CCoeControl.

Handles a change to Edwin s resources which are shared across the environment. Colours or fonts for example.

Handles a change to the control's resources of type aType which are shared across the environment, e.g. colors or fonts. For this particular control aType can be a request of handling either the caps lock modifier or the virtual cursor state.

From MEikScrollBarObserver.

Handles scrollbar key events.

Handles scrollbar events with kinetic scrolling.

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.

Handles all modifications made by reformatting the entire document. Calls CEikEdwin::FormatText() and redraws Edwin contents and scroll bars if they are ready to be redrawn.

Not implemented.

Gets highlight style.

Uses SetScrollBarsL() to set the scrollbars.

From 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.

Replaces the cursor selection with the identified text.

Inserts a field at the current cursor position. If a selection was made the field replaces that selection.

Inserts the contents of a text file into the text being edited at the current cursor position.

Tests if the background drawing is suppressed.

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

Determines whether the document being edited with Edwin is read-only.

check the selection content is visible character or not

Returns ETrue if kinetic scrolling is enabled.

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 SetWysiwygModeOn() for example.

Gets the width of a line cursor in pixels.

Gets the lower limit for formatting. This returns the value of KPartialFormattingLowerThreshold which determines when a switch is made from formatting only visible text to formatting all text. When the text length exceeds the KFullFormattingUpperThreshold only visible text is formatted. If some characters are deleted so that the text length is less than KFullFormattingUpperThreshold the entire text is still not formatted. Instead, reformatting occurs only when the number of characters is less than the value of KPartialFormattingLowerThreshold.

Gets the text view margins.

Gets the editor maximum length.

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 MaximumHeightInLines instead.

Returns the maximum edwin height.

Gets editor maximum height in lines.

Gets the minimum Edwin height.

Returns the minimum edwin height.

From CCoeControl.

Gets the minimum size of this Edwin for automatic-layout control contexts such as dialogs.

From MObjectProvider.

Retrieves an object of the same type as that encapsulated in 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 ETypeId member of the object pointed to by the pointer returned by this function must be equal to the iUid member of aId.

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.

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.

Scrolls the text either horizontally or vertically without affecting the cursor s position.

Standard check on upper and lower formatting thresholds versus current textview formatting mode.

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.

Sets non-printing characters?visibility.

This call causes FEP to reset current editing state and new editing state is fetched from CAknEdwinState object.

Formats and draws a new document, updates scrollbars if necessary.

Reformats and redraws the document, updates scrollbars if necessary.

From CCoeControl.

Handles key events.

Confirms whether the deletion of the user s selection is required.

If the user s selection is less than KBlockDeleteWarningSize and does not contain a picture, this function returns ETrue.

If the user s selection is greater than KBlockDeleteWarningSize or contains a picture, this function asks the user to confirm deletion of their selection and then returns the user s response.

From CTextView::MObserver.

Called after reformatting but before redisplay so that edit windows etc. can be resized.

Reports the event EEventSizeChanging to the observer every time the text view height changes.

Tests whether the EOnlyASCIIChars flag is set.

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.

Returns pictograph animation callback. If it is not set, the function pointer is NULL.

Returns amount of pixels how much we are out of borders.

Copies the contents of the cursor selection onto the clipboard.

Used in ConstructFromResourceL(). Sets Avkon editor properties.

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.

Removes the specified observer from the list of observers. Does nothing if aEdwinObserver is not an observer.

Removes aEdwinObserver form the list of observers. Does nothing if aEdwinObserver isn't an observer.

Removes user flags. See TFlags.

Replaces all occurrences of a string with new text. Both old and new text are held in aFindModel.

Replaces the highlighted text. See SEdwinFindModel struct.

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.

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 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.

Show cursor again if needed (based on stored cursor visibility info).

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.

Gets the scroll bar frame surrounding this Edwin.

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)

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.

Selects the entire document.

Gets the cursor selection. If no text view is associated to the Edwin this returns TCursorSelection(0,0).

Gets the number of characters including non-printing characters within the selection.

Sends the Edwin s document using an infra red beamer.

Sets allowed input modes for the editor. All input modes are allowed (EAknEditorAllInputModes) if the value is not set from EDWIN resource allowed_input_modes or with this API.

Sets default case for the editor. The case is used when the editor is focused first time. Available case flags from uikon.hrh are EAknEditorUpperCase, EAknEditorLowerCase and EAknEditorTextCase. EAknEditorTextCase is used if the initial case is not set from EDWIN resource default_case or with this API.

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 uikon.hrh are EAknEditorUpperCase, EAknEditorLowerCase and EAknEditorTextCase. This method should not be used to set initial case for the editor. Use SetAknEditorCase() method instead for setting initial case.

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 SetAknEditorInputMode() method instead for setting initial input mode.

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.

Sets default input mode for the editor. The input mode is used when the editor is focused first time. EAknEditorTextInputMode is used if the initial input mode is not set from EDWIN resource default_input_mode or with this API.

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.

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. EAknEditorStandardNumberModeKeymap is used in editors that allow only numeric input if the mapping is not set from EDWIN resource numeric_keymap or with this API. EAknEditorAlphanumericNumberModeKeymap is used as default if the editor allows also text input mode.

Sets permitted cases for the editor. Possible flags from uikon.hrh are EAknEditorAllCaseModes, EAknEditorUpperCase, EAknEditorLowerCase and EAknEditorTextCase. EAknEditorAllCaseModes is used if the value is not set from EDWIN resource allowed_case_modes or with this API.

Sets editor specific special character table.

Stores the alignment value for an editor.

Sets whether the document accepts pictures.

Sets whether the undo operation is permitted.

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.

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.

Sets the average number of characters per line.

Sets the average number of lines displayed in Edwin s view.

Sets the EAvkonEditor flag.

Sets the Edwin s background colour.

Sets the text view margins.

Sets the character format layer for the editor. Ownership of the CCharFormatLayer is transferred.

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

From CCoeControl.

Sets the containing window for the Edwin by copying it from the specified parent. Also copies a control context from aParent if one has not been previously set.