class CPlainText : public CEditableText |
Stores and manipulates plain text.
Plain text cannot be displayed, so this class provides no support for formatting. It is purely an in-memory buffer for text, and provides services that act upon it. These services include the following: import from and export to streams, optionally translating between Unicode and other encodings; reading and writing of field data; extraction of text; finding word and paragraph boundaries.
The type and size of in-memory buffer can be specified upon object construction. However, if no specification is provided a buffer is provided with default settings. There are two types of storage buffer: segmented buffers and flat buffers. The default buffer for plain text is segmented ( CBufSeg ). This is most efficient when a large quantity of text is to be stored, or will have a large dynamic range. A flat buffer ( CBufFlat ) is most appropriate for storing small quantities of text of bounded length. For most uses, however, a segmented buffer is sufficient.
Private Member Functions | |
---|---|
CPlainText (const CPlainText &) | |
TInt | CountUnits ( TUnitOfText ) |
void | CreateFieldSetL ( TInt ) |
TInt | DoPasteFromStreamL ( RReadStream &, TInt ) |
TBool | FieldSetPresent () |
TBool | GetChar ( SScanData &, TChar &) |
void | InitScanControl ( TInt &, TUint &, TUnitOfText , SScanData &) |
void | InitScanData ( TInt , SScanData &) |
void | InsertEodL () |
void | KillFieldSet () |
TInt | PasteFromStreamL ( RReadStream &, TInt ) |
IMPORT_C void | Reserved_2 () |
TInt | ScanUnit ( TInt &, TUnitOfText , SScanData &) |
TBool | TestForDelimiter ( TUnitOfText , SScanData &) |
void | UpdatePageTable ( TInt , TInt ) |
CPlainText & | operator= (const CPlainText &) |
Public Member Enumerations | |
---|---|
enum |
anonymous
{
EScanBackwards = 0x01, EScanStayIfBoundary = 0x02, EScanToUnitStart = 0x04, EScanToUnitEnd = 0x08, EScanJoinDelimiters = 0x10, EScanPictureIsDelimiter = 0x20, EScanPunctuationIsDelimiter = 0x40 } |
enum | anonymous { EExtractAll = 0, EExtractVisible = 1, EExcludeInlineEditedText = 2 } |
enum | TScanDataEnd { EScanEndOfData = -1 } |
enum | TTextOrganisation { EOrganiseByParagraph , EOrganiseByLine } |
Protected Member Enumerations | |
---|---|
enum | anonymous { EImportBufSize = 512, EBiggestCharacterPaste = 0x100000 } |
enum | TUnitOfText { EUnitIsWord , EUnitIsParagraph } |
Inherited Enumerations | |
---|---|
CEditableText:@49 | |
CEditableText:@50 | |
CEditableText:TDocumentStorage |
Protected Attributes | |
---|---|
__DECLARE_TEST | |
CBufBase * | iByteStore |
MTextFieldFactory * | iFieldFactory |
TSwizzle < CTextFieldSet > | iFieldSet |
TPageTable * | iPageTable |
Private Attributes | |
---|---|
void * | iReserved_1 |
Inherited Attributes | |
---|---|
CEditableText::iHasChanged |
CPlainText | ( | const CPlainText & | aPlainTextDoc | ) | [private] |
const CPlainText & aPlainTextDoc |
IMPORT_C | ~CPlainText | ( | ) | [virtual] |
The destructor frees the object's text storage and field set, prior to its destruction.
IMPORT_C TInt | CharPosOfParagraph | ( | TInt & | aLength, |
TInt | aParaOffset | |||
) | const [virtual] |
Finds the length and the start position of a paragraph identified by its paragraph number the first paragraph is numbered zero.
Notes:
if aParaOffset is invalid, (equal to or greater than the total number of paragraphs), the function's return value is EScanEndOfData
IMPORT_C TEtextComponentInfo | ComponentInfo | ( | ) | const [virtual] |
Gets information about the number of components contained in the text object. For plain text, only the field count has relevance.
IMPORT_C void | ConstructL | ( | TDocumentStorage | aStorage = ESegmentedStorage, |
TInt | aDefaultTextGranularity = EDefaultTextGranularity | |||
) | [protected] |
TDocumentStorage aStorage = ESegmentedStorage | |
TInt aDefaultTextGranularity = EDefaultTextGranularity |
IMPORT_C void | ConstructL | ( | const CStreamStore & | aStore, |
TStreamId | aStreamId, | |||
MTextFieldFactory * | aFieldFactory, | |||
TDocumentStorage | aStorage = ESegmentedStorage | |||
) | [protected] |
const CStreamStore & aStore | |
TStreamId aStreamId | |
MTextFieldFactory * aFieldFactory | |
TDocumentStorage aStorage = ESegmentedStorage |
void | ConsumeAdornmentL | ( | RReadStream & | aStream | ) | [protected, static, inline] |
RReadStream & aStream |
IMPORT_C void | ConvertAllFieldsToText | ( | ) |
Removes all fields from the text object's field set, leaving their current text value in the text object. Does not update the fields beforehand.
IMPORT_C TBool | ConvertFieldToText | ( | TInt | aPos | ) |
Converts the field containing the specified document position into text, leaving its current value in the text object. Does not update the field beforehand.
TInt aPos | A document position within the field to convert. Must be a valid position or a panic occurs. |
void | CopyComponentsL | ( | CStreamStore & | aStore, |
CStoreMap & | aMap, | |||
TInt | aPos, | |||
TInt | aLength | |||
) | const [protected] |
CStreamStore & aStore | |
CStoreMap & aMap | |
TInt aPos | |
TInt aLength |
IMPORT_C void | CopyToStoreL | ( | CStreamStore & | aStore, |
CStreamDictionary & | aDictionary, | |||
TInt | aPos, | |||
TInt | aLength | |||
) | const [virtual] |
Copies plain text including fields, if present, to the clipboard.
A panic occurs in any of the following circumstances:
aPos is invalid
aLength is invalid (zero or less)
the sum of aPos and aLength is greater than or equal to the number of characters in the document
CStreamStore & aStore | Stream store to which the text is written. |
CStreamDictionary & aDictionary | The stream dictionary. |
TInt aPos | The document position from which to begin copying. |
TInt aLength | The number of characters to copy. |
void | CopyToStreamL | ( | RWriteStream & | aStream, |
TInt | aPos, | |||
TInt | aLength | |||
) | const [protected] |
RWriteStream & aStream | |
TInt aPos | |
TInt aLength |
TInt | CountUnits | ( | TUnitOfText | aContext | ) | const [private] |
TUnitOfText aContext |
void | CreateFieldSetL | ( | TInt | aDocumentLength | ) | [private] |
TInt aDocumentLength |
IMPORT_C TBool | DeleteL | ( | TInt | aPos, |
TInt | aLength | |||
) | [virtual] |
Deletes one or more characters beginning at, and including, the character at a specified document position. Updates the page table. Any fields wholly contained in the range of characters to delete are removed from the field set.
IMPORT_C void | DoConstructL | ( | TDocumentStorage | aStorage, |
TInt | aDefaultTextGranularity, | |||
MTextFieldFactory * | aFieldFactory = NULL | |||
) | [protected] |
TDocumentStorage aStorage | |
TInt aDefaultTextGranularity | |
MTextFieldFactory * aFieldFactory = NULL |
TStreamId | DoCopyToStoreL | ( | CStreamStore & | aStore, |
CStreamDictionary & | aDictionary, | |||
TInt | aPos, | |||
TInt | aLength | |||
) | const [protected] |
CStreamStore & aStore | |
CStreamDictionary & aDictionary | |
TInt aPos | |
TInt aLength |
IMPORT_C void | DoExternalizeFieldDataL | ( | RWriteStream & | aStream | ) | const [protected] |
Write to the stream, the T.V. representing the field set.
RWriteStream & aStream |
IMPORT_C void | DoExternalizePlainTextL | ( | RWriteStream & | aStream | ) | const [protected] |
Write to the stream, the T.V. representing the plain text.
RWriteStream & aStream |
void | DoExtract | ( | TDes & | aBuf, |
TInt | aPos, | |||
TInt | aLength, | |||
TUint | aFlags = 0 | |||
) | const [protected] |
Copies aLength characters, commencing at aPos, into the specified buffer aBuf. If aLength is greater than the amount of data left, then all remaining characters are written.
IMPORT_C void | DoInternalizeFieldDataL | ( | RReadStream & | aStream | ) | [protected] |
Read from the stream until the field data is identified, and consume it.
RReadStream & aStream |
IMPORT_C void | DoInternalizePlainTextL | ( | RReadStream & | aStream | ) | [protected] |
Read from the stream until the character data is found, and consume it.
RReadStream & aStream |
TInt | DoPasteFromStoreL | ( | const CStreamStore & | aStore, |
TStreamId | aStreamId, | |||
TInt | aPos | |||
) | [protected] |
const CStreamStore & aStore | |
TStreamId aStreamId | |
TInt aPos |
TInt | DoPasteFromStreamL | ( | RReadStream & | aStream, |
TInt | aPos | |||
) | [private] |
RReadStream & aStream | |
TInt aPos |
IMPORT_C TBool | DoPtDelete | ( | TInt | aPos, |
TInt | aLength | |||
) | [protected] |
Deletes aLength number of characters from the document, commencing at, and including, position aPos. The return value indicates if 2 paragraphs have been merged together as a result of the delete, indicating that the resulting paragraph must be reformatted. In global text, this clearly has no reasonable meaning, so always returns EFalse, so no reformatting occurs.
IMPORT_C void | DoPtInsertL | ( | TInt | aPos, |
const TDesC & | aBuf | |||
) | [protected] |
Inserts the contents a aBuf into the document at position aInsertPos. Maintain field set.
IMPORT_C TInt | DocumentLength | ( | ) | const [virtual] |
Gets the the number of characters in the text object.
Note: the count includes all non-printing characters but excludes the end of text paragraph delimiter, so that the smallest possible return value is zero.
IMPORT_C void | ExportAsTextL | ( | const TDes & | aFileName, |
TTextOrganisation | aTextOrganisation, | |||
TInt | aMaxLineLength | |||
) | const [virtual] |
Writes the contents of the plain text object to a text file.
The filename is given by aFileName. Any existing file with that name is replaced. A wrap width can be specified. This is only used when exporting by line (aTextOrganisation is EOrganiseByLine).
The function leaves if there is any problem in creating or replacing the file.
const TDes & aFileName | The name of the file to export the text to. If a file with this name already exists, it is replaced. Otherwise, a new file is created. |
TTextOrganisation aTextOrganisation | Defines how to translate line delimiters. If EOrganiseByLine, lines wrap at the wrap width, as specified in aMaxLineLength. If EOrganiseByParagraph, lines do not wrap and paragraph delimiters are converted into CR/LF pairs. |
TInt aMaxLineLength | The maximum number of characters in each line, (only relevant if the text organisation is EOrganiseByLine). |
IMPORT_C void | ExportTextL | ( | TInt | aPos, |
RWriteStream & | aOutput, | |||
TTextOrganisation | aTextOrganisation, | |||
TInt | aMaxOutputChars = KMaxTInt , | |||
TInt | aMaxInputChars = KMaxTInt , | |||
TInt | aMaxLineLength = KMaxTInt , | |||
TInt * | aOutputChars = NULL, | |||
TInt * | aInputChars = NULL | |||
) | const |
Writes plain text to a stream, optionally converting it from Unicode into a foreign encoding.
TInt aPos | A document position in the source plain text object from which to start reading the text to export. |
RWriteStream & aOutput | On return, the write stream to which the text is written. |
TTextOrganisation aTextOrganisation | |
TInt aMaxOutputChars = KMaxTInt | |
TInt aMaxInputChars = KMaxTInt | |
TInt aMaxLineLength = KMaxTInt | |
TInt * aOutputChars = NULL | |
TInt * aInputChars = NULL |
IMPORT_C void | ExportTextL | ( | TInt | aPos, |
RWriteStream & | aOutput, | |||
const TImportExportParam & | aParam, | |||
TImportExportResult & | aResult | |||
) | const |
Writes plain text to a stream, optionally converting it from Unicode into a foreign encoding.
CPlainText::TImportExportParam CPlainText::TImportExportResult
TInt aPos | A document position in the source plain text object from which to start reading the text to export. |
RWriteStream & aOutput | On return, the write stream to which the text is written. |
const TImportExportParam & aParam | Export parameters, including an optional foreign encoding to convert the Unicode text into, a file server connection, (this is needed for the character conversion if not specified, one will be created), a line wrap width, and the maximum number of characters to export. |
TImportExportResult & aResult | On return, contains the number of characters read and written. |
IMPORT_C void | ExtendedInterface | ( | TAny *& | aInterface, |
TUid | aInterfaceId | |||
) | [virtual] |
Returns the interface corresponding to the specified UID if it exists, or 0 if not. Overridden versions should base call rather than returning 0.
IMPORT_C void | ExternalizeFieldDataL | ( | RWriteStream & | aStream | ) | const |
Externalises the plain text object's field set.
RWriteStream & aStream | The stream to which the field set should be written. |
IMPORT_C void | ExternalizeL | ( | RWriteStream & | aStream | ) | const [virtual] |
Externalises a plain text object to a write stream. The presence of this function means that the standard templated operator<<() (defined in s32strm.h) is available to externalise objects of this class.
RWriteStream & aStream | Stream to which the object should be externalised. |
IMPORT_C void | ExternalizePlainTextL | ( | RWriteStream & | aStream | ) | const |
Externalises the plain text object's text content (preceded by a length count) to a write stream.
RWriteStream & aStream | Stream to which the text content should be externalised. |
IMPORT_C void | ExternalizePlainTextNoLengthCountL | ( | RWriteStream & | aStream | ) | const |
Externalises the plain text object's text content to a write stream.
This function differs from ExternalizePlainTextL() in that it does not precede the text content with a length count. This function is not intended for general use and is deprecated. void CPlainText::ExternalizePlainTextL(RWriteStream& aStream)const
RWriteStream & aStream |
IMPORT_C void | Extract | ( | TDes & | aBuf, |
TInt | aPos = 0 | |||
) | const [virtual] |
Copies the contents of the text object into a descriptor overloaded function. The function copies all characters from and including the document position specified, to the end of the document or the end of the range of characters, if specified.
The buffer's maximum length must be greater than or equal to the number of characters to extract, or a panic occurs.
IMPORT_C void | Extract | ( | TDes & | aBuf, |
TInt | aPos, | |||
TInt | aLength | |||
) | const [virtual] |
Copies the contents of the text object into a descriptor-overloaded function. The function copies all characters from and including the document position specified, to the end of the document or the end of the range of characters, if specified.
The buffer's maximum length must be greater than or equal to aLength, or a panic ocurs.
IMPORT_C void | ExtractSelectively | ( | TDes & | aBuf, |
TInt | aPos, | |||
TInt | aLength, | |||
TUint | aFlags | |||
) |
IMPORT_C TInt | FieldCount | ( | ) | const |
Gets a count of the number of fields in the text object's field set.
IMPORT_C const MTextFieldFactory * | FieldFactory | ( | ) | const |
Gets a pointer to the field factory used by the text object. The field factory may be set up using SetFieldFactory() , or may be specified in the NewL() .
IMPORT_C TBool | FindFields | ( | TFindFieldInfo & | aInfo, |
TInt | aPos, | |||
TInt | aRange = 0 | |||
) | const |
Tests whether a document position is located within a field overloaded function.
The second overload extracts information about all fields located within a range of characters.
TFindFieldInfo & aInfo | On return, contains the number of fields fully or partially within the range of characters specified and the start position and length of the first field found. |
TInt aPos | The document position. Must be valid or a panic occurs. |
TInt aRange = 0 | The number of characters to search, beginning at aPos. Must not be negative, or a panic occurs. The sum of aPos and aRange must be less than the document length, or a panic occurs. The default range is zero. In this case the function just returns information about the single field located at the position specified. |
TBool | GetChar | ( | SScanData & | aScanData, |
TChar & | aChar | |||
) | const [private] |
IMPORT_C void | GetWordInfo | ( | TInt | aCurrentPos, |
TInt & | aStartPos, | |||
TInt & | aLength, | |||
TBool | aPictureIsDelimiter, | |||
TBool | aPunctuationIsDelimiter | |||
) | const [virtual] |
Gets the start position and length of the word that contains the document position specified.
TInt aCurrentPos | A document position. Must be valid or a panic occurs. |
TInt & aStartPos | On return, the document position of the first character in the word containing the position aCurrentPos. |
TInt & aLength | On return, the length of the word containing document position aCurrentPos. |
TBool aPictureIsDelimiter | ETrue if picture characters should be treated as word delimiters, false if not. For example, when navigating text, this might be EFalse, but when spell checking, it might be ETrue. |
TBool aPunctuationIsDelimiter | ETrue if punctuation characters should be treated as word delimiters, EFalse if not. |
IMPORT_C TInt | ImportTextFileL | ( | TInt | aPos, |
const TDes & | aFileName, | |||
TTextOrganisation | aTextOrganisation | |||
) | [virtual] |
Imports a plain text file into this text object.
Translates non-printing characters in the source text file into Symbian OS special characters, for instance tabs are converted into CEditableText::ETabCharacters, and form feeds into CEditableText::EPageBreaks. Line feeds in the source text file are translated according to the aTextOrganisation argument.
The function leaves if there is any problem in opening the file.
TInt aPos | Document position at which to insert the text. Must be a valid position, or a panic occurs. |
const TDes & aFileName | The name of the text file to import. |
TTextOrganisation aTextOrganisation | If EOrganiseByLine, a single line feed or a line feed and carriage return is converted into a space character. A line feed which is followed by another line feed is converted into a paragraph delimiter. If EOrganiseByParagraph, all line feeds are converted into paragraph delimiters. |
IMPORT_C void | ImportTextL | ( | TInt | aPos, |
RReadStream & | aInput, | |||
TTextOrganisation | aTextOrganisation, | |||
TInt | aMaxOutputChars = KMaxTInt , | |||
TInt | aMaxInputChars = KMaxTInt , | |||
TInt * | aOutputChars = NULL, | |||
TInt * | aInputChars = NULL | |||
) |
Imports plain text from a stream into this text object.
Translates line feeds in the source text according to the aTextOrganisation argument.
TInt aPos | Document position at which to insert the text. Must be a valid position, or a panic occurs. |
RReadStream & aInput | Stream from which to read the text. |
TTextOrganisation aTextOrganisation | If EOrganiseByLine, a single line feed or a line feed and carriage return is converted into a space character. A line feed which is followed by another line feed is converted into a paragraph delimiter. If EOrganiseByParagraph, all line feeds are converted into paragraph delimiters. |
TInt aMaxOutputChars = KMaxTInt | The maximum number of characters to write to the text object. |
TInt aMaxInputChars = KMaxTInt | The maximum number of characters to read from the stream. |
TInt * aOutputChars = NULL | On return, the number of characters written to the text object. |
TInt * aInputChars = NULL | On return, the number of characters read from the stream. |
IMPORT_C void | ImportTextL | ( | TInt | aPos, |
RReadStream & | aInput, | |||
const TImportExportParam & | aParam, | |||
TImportExportResult & | aResult | |||
) |
Imports plain text from a stream into this text object, optionally converting it from a foreign encoding into Unicode.
CPlainText::TImportExportParam CPlainText::TImportExportResult
TInt aPos | Document position at which to insert the text. Must be a valid position, or a panic occurs. |
RReadStream & aInput | Stream from which to read the text. |
const TImportExportParam & aParam | Import parameters, including the foreign encoding to convert from, whether to guess the foreign encoding and the maximum number of characters to import. |
TImportExportResult & aResult | On return, contains the number of characters read and written and the foreign encoding used by the imported text. |
void | InitScanControl | ( | TInt & | aPos, |
TUint & | aScanMask, | |||
TUnitOfText | aContext, | |||
SScanData & | aScanData | |||
) | const [private] |
TInt & aPos | |
TUint & aScanMask | |
TUnitOfText aContext | |
SScanData & aScanData |
void | InitScanData | ( | TInt | aPos, |
SScanData & | aScanData | |||
) | const [private] |
void | InsertEodL | ( | ) | [private] |
Inserts the end-of-document character upon document construction.
IMPORT_C void | InsertFieldL | ( | TInt | aPos, |
CTextField * | aField, | |||
TUid | aFieldType | |||
) |
Inserts a field into the text object at a specified document position. creating a zero-length field record. Maintain the field set.
Note: After insertion, the field should be evaluated in order to make its contents visible; use UpdateFieldL() .
TInt aPos | The document position at which to insert the field. Must be valid, or a panic occurs. |
CTextField * aField | The field to insert, created by NewTextFieldL(). Must not be NULL, or a panic occurs. |
TUid aFieldType | Identifies the type of field to insert. For the built in field types, see the UID values defined in flddef.h. |
IMPORT_C void | InsertL | ( | TInt | aPos, |
const TChar & | aChar | |||
) | [virtual] |
Inserts either a single character or a descriptor into the text object at a specified document position.
Updates the page table.
IMPORT_C void | InsertL | ( | TInt | aPos, |
const TDesC & | aBuf | |||
) | [virtual] |
Inserts the contents of aBuf into the document at position aPos.
void | InsertL | ( | TInt | aPos, |
const CPlainText * | aText | |||
) | [protected] |
Insert the specified plain text object at the specified character position. (Called by CRichText::Insert()
TInt aPos | |
const CPlainText * aText |
IMPORT_C void | InternalizeFieldDataL | ( | RReadStream & | aStream | ) |
Internalizes the field set.
RReadStream & aStream | The read stream from which the field set is read. |
IMPORT_C void | InternalizeL | ( | RReadStream & | aStream | ) | [virtual] |
Internalises the text object's text content and field set from a read stream. The presence of this function means that the standard templated operator>>() (defined in s32strm.h) is available to internalise objects of this class. InternalizeL() has construct rather than assignment semantics. You should not use it for fully initialised objects.
RReadStream & aStream | Stream from which the object should be internalised. |
IMPORT_C void | InternalizePlainTextL | ( | RReadStream & | aStream | ) |
Internalises an empty text object's text content from a read stream overloaded function.
This function has construct rather than assignment semantics. You should not use it for fully initialised objects.NoteThe overload which takes a length argument is not intended for general use and its use is deprecated.
RReadStream & aStream | Stream from which the object should be internalised. |
IMPORT_C void | InternalizePlainTextL | ( | RReadStream & | aStream, |
TInt | aLength | |||
) |
Internalises an empty text object's text content from a read stream's overloaded function.
This function has construct rather than assignment semantics. You should not use it for fully initialised objects.
Note
The overload which takes a length argument is not intended for general use and its use is deprecated.
RReadStream & aStream | Stream from which the object should be internalised. |
TInt aLength | Indicates the number of characters which should be read, after expansion from their compressed format. |
IMPORT_C CPlainText * | NewL | ( | TDocumentStorage | aStorage = ESegmentedStorage, |
TInt | aDefaultTextGranularity = EDefaultTextGranularity | |||
) | [static] |
Allocates and constructs a plain text object overloaded function.
The text object's contents may be restored from a stream store. If the text object supports fields, a field factory should be specified.
TDocumentStorage aStorage = ESegmentedStorage | The type of in-memory buffer to use. Defaults to ESegmentedStorage. |
TInt aDefaultTextGranularity = EDefaultTextGranularity | Specifies the granularity of the in-memory buffer. Default is EDefaultTextGranularity bytes (=256). |
IMPORT_C CPlainText * | NewL | ( | const CStreamStore & | aStore, |
TStreamId | aStreamId, | |||
MTextFieldFactory * | aFieldFactory = NULL, | |||
TDocumentStorage | aStorage = ESegmentedStorage | |||
) | [static] |
Returns a handle to a new instance of this class, restored from the specified read stream.
const CStreamStore & aStore | |
TStreamId aStreamId | |
MTextFieldFactory * aFieldFactory = NULL | |
TDocumentStorage aStorage = ESegmentedStorage |
IMPORT_C CTextField * | NewTextFieldL | ( | TUid | aFieldType | ) | const |
Creates and returns a new field. Before calling this function, a field factory should have been set up, either by calling SetFieldFactory() , or by specifying one in the NewL() . The field factory's NewFieldL() function is called to create a field of the type specified in the argument. A NULL field is returned if no field factory has been set up.
TUid aFieldType | Identifies the field type. |
IMPORT_C TInt | PageContainingPos | ( | TInt | aPos | ) | const |
Gets the number of the page which contains the specified document position. If no page table has been set up, the function returns a value of zero. Use SetPageTable() to set up the page table.
TInt aPos | A document position. Must be valid or a panic occurs. |
IMPORT_C TInt | ParagraphCount | ( | ) | const [virtual] |
Gets a count of the number of paragraphs in the text object.
Note: the paragraph delimiter which terminates every text object means this function always returns a count of at least one.
IMPORT_C TInt | ParagraphNumberForPos | ( | TInt & | aPos | ) | const [virtual] |
Gets the number of the paragraph which contains a document position. Paragraph numbering begins at zero.
TInt & aPos | A document position. Must be valid or a panic occurs. On return, contains the document position of the first character in the paragraph in which it is located. |
void | PasteComponentsL | ( | const CStreamStore & | aStore, |
TInt | aPos | |||
) | [protected] |
const CStreamStore & aStore | |
TInt aPos |
IMPORT_C TInt | PasteFromStoreL | ( | const CStreamStore & | aStore, |
const CStreamDictionary & | aDictionary, | |||
TInt | aPos | |||
) | [virtual] |
Pastes plain text and fields, if present, from the clipboard into the current text object at the specified document position. The entire contents of the store are pasted.
const CStreamStore & aStore | The steam store from which to paste the text. |
const CStreamDictionary & aDictionary | The stream dictionary. |
TInt aPos | Document position at which to paste. Must be valid or the function raises a panic. |
TInt | PasteFromStreamL | ( | RReadStream & | aStream, |
TInt | aPos | |||
) | [private] |
RReadStream & aStream | |
TInt aPos |
IMPORT_C void | PtInsertL | ( | TInt | aInsertPos, |
const TDesC & | aBuf | |||
) | [protected] |
Inserts the contents a aBuf into the document at position aInsertPos. Maintain field set.
IMPORT_C TPtrC | Read | ( | TInt | aStartPos | ) | const [virtual] |
Gets a read-only view of a portion of the text object.
The extent of the view is the range of characters starting at aStartPos and ending at whichever of the following document positions is reached first:
The end of the document.
The end of the segment if using segmented storage (the storage type is specified in the NewL() .
Therefore, when using a segmented buffer to store the document, the length of the resultant view may be less than the requested length. In this case multiple calls to Read() may be necessary.
TInt aStartPos | The document position at which to begin reading. Must be valid or a panic occurs. |
IMPORT_C TPtrC | Read | ( | TInt | aStartPos, |
TInt | aLength | |||
) | const [virtual] |
Gets a read-only view of a portion of the text object.
The extent of the view is the range of characters starting at aStartPos and ending at whichever of the following document positions is reached first:
The end of the document.
The end of the segment if using segmented storage (the storage type is specified in the NewL() .
The sum of aStartPos and (aLength-1).
Therefore, when using a segmented buffer to store the document, the length of the resultant view may be less than the requested length. In this case multiple calls to Read() may be necessary.
IMPORT_C TBool | RemoveField | ( | TInt | aPos | ) |
Removes the field covering the document position specified from the field set, and deletes all text content associated with the field from the text object.
TInt aPos | A document position within the field to be deleted. Must be a valid position or a panic occurs. |
IMPORT_C void | Reset | ( | ) | [virtual] |
Deletes all text content, formatting and fields from the document, leaving the single paragraph delimiter which terminates the text object.
IMPORT_C void | RestoreComponentsL | ( | const CStreamStore & | aStore | ) | [virtual] |
Restores the plain text object's field set from a stream store.
const CStreamStore & aStore | The stream store from which the field set is restored. |
IMPORT_C void | RestoreFieldComponentsL | ( | const CStreamStore & | aStore | ) |
Restores the plain text object's field set.
const CStreamStore & aStore | The stream store from which the fields are restored. |
IMPORT_C TInt | ScanParas | ( | TInt & | aPos, |
TUint & | aScanMask | |||
) | const [virtual] |
Scans from a document position to the beginning or end of a paragraph. The destination is determined by a scan mask. The scan can either be forwards (the default) or backwards, and the destination may be the first or last character in the paragraph containing the position, or the first character in the next paragraph.
Note: if an attempt is made to scan beyond the end of text delimiter, on return, aPos is set to EScanEndOfData ) and the function's return value indicates the number of characters skipped in passing the end of text delimiter.
TInt | ScanUnit | ( | TInt & | aPos, |
TUnitOfText | aContext, | |||
SScanData & | aScanData | |||
) | const [private] |
TInt & aPos | |
TUnitOfText aContext | |
SScanData & aScanData |
IMPORT_C TInt | ScanWords | ( | TInt & | aPos, |
TUint & | aScanMask | |||
) | const [virtual] |
Scans from a document position to the beginning or end of a word. The destination is determined by a scan mask. The scan can either be forwards (the default) or backwards, and the destination may be the first or last character in the word containing the position, or the first character in the next word.
Note: If an attempt is made to scan beyond the end of text delimiter, on return, aPos is set to EScanEndOfData and the function's return value indicates the number of characters skipped in passing the end of text delimiter.
IMPORT_C void | SetFieldFactory | ( | MTextFieldFactory * | aFactory | ) |
Sets up a field factory. A field factory is an instance of a class deriving from MTextFieldFactory . It must implement a NewFieldL() function to create and return fields of the desired type. The field factory's NewFieldL() function is called by CPlainText::NewTextFieldL() . A field factory must be set up if you intend to add any fields to the text object.
MTextFieldFactory * aFactory | The field factory. |
IMPORT_C void | SetPageTable | ( | TPageTable * | aPageTable | ) |
Links the text object to a page table. A page table is an array of integers; each integer represents the number of characters on a page. It is required for pagination. The page table is updated when changes are made to the document, e.g. after pasting from the clipboard, inserting, importing or deleting text.
The text object does not take ownership of the page table specified.
TPageTable * aPageTable | The page table to be referenced by the text object. |
IMPORT_C void | StoreComponentsL | ( | CStreamStore & | aStore, |
CStoreMap & | aMap | |||
) | const [virtual] |
Stores the plain text object's components to the stream store specified.
CStreamStore & aStore | Stream store to which the text object's components are written. |
CStoreMap & aMap | A store map. This binds the address of each component to the stream ID of aStore. This is needed to support the deferred loading of pictures in rich text. |
IMPORT_C void | StoreFieldComponentsL | ( | CStreamStore & | aStore, |
CStoreMap & | aMap | |||
) | const |
Stores the plain text object's field components to a stream store.
CStreamStore & aStore | Stream store to which the fields are written. |
CStoreMap & aMap | A store map. This binds the address of each text component to the stream ID of aStore. This is needed to support the deferred loading of pictures in rich text. |
TBool | TestForDelimiter | ( | TUnitOfText | aContext, |
SScanData & | aScanData | |||
) | const [private] |
Return ETrue if a character was read successfully. Set EIsDelimiter flag if the character read is a delimiter of the appropriate type.
TUnitOfText aContext | |
SScanData & aScanData |
IMPORT_C const CTextField * | TextField | ( | TInt | aPos | ) | const |
Returns a pointer to the field located at the specified document position.
TInt aPos | A document position within the field. Must be a valid document position, or a panic occurs. |
IMPORT_C TInt | ToParagraphStart | ( | TInt & | aPos | ) | const [virtual] |
Gets the document position of the start of the paragraph containing the specified document position.
TInt & aPos | A document position. Must be valid or a panic occurs. On return, contains the document position of the first character in the paragraph in which it is located. |
TUid | UidFromStreamL | ( | RReadStream & | aStream | ) | [protected, static, inline] |
RReadStream & aStream |
IMPORT_C void | UpdateAllFieldsL | ( | ) |
Re-evaluates all of the fields in the text object. Re-evaluating a field means calculating the field's new value, then inserting that value into the text object, replacing the previous value.
Note: Fields have a maximum length of 20 characters.
IMPORT_C void | UpdateFieldL | ( | TInt | aPos | ) | [virtual] |
Re-evaluates the field which covers the document position specified. Re-evaluating a field means calculating the field's new value, then inserting that value into the text object, replacing the previous value.
Notes:
fields have a maximum length of 20 characters.
the first time a field is updated, the position specified should be the position at which the field was inserted.
TInt aPos | A document position in the field to be updated. Must be a valid position, or a panic occurs. |
IMPORT_C TInt | WordCount | ( | ) | const [virtual] |
Gets a count of the number of words in the text object.
CPlainText & | operator= | ( | const CPlainText & | aPlainTextDoc | ) | [private] |
const CPlainText & aPlainTextDoc |
Scan mask values.
EScanBackwards = 0x01 |
Scan direction is backwards. The default is forwards. |
EScanStayIfBoundary = 0x02 |
If the current document position is a word or paragraph boundary, no scan occurs. |
EScanToUnitStart = 0x04 |
Scan to the first character in the word or paragraph. |
EScanToUnitEnd = 0x08 |
Scan to the last character in the word or paragraph. |
EScanJoinDelimiters = 0x10 |
Treat adjacent word or paragraph delimiters as a single delimiter. Required when performing a word count, for example. |
EScanPictureIsDelimiter = 0x20 |
Picture characters are considered to be word delimiters. |
EScanPunctuationIsDelimiter = 0x40 |
Punctuation characters, except hyphens and apostrophes, are considered to be word delimiters. |
Used in text scanning functions to indicate the end of the document has been passed.
EScanEndOfData = -1 |
Indicates that a scan has passed the end of text paragraph delimiter. |
Line delimiter translation.
EOrganiseByParagraph |
When importing text from a text file, all line feeds are converted into paragraph delimiters. When exporting text to a text file, lines do not wrap and paragraph delimiters are converted into CR/LF pairs. |
EOrganiseByLine |
When importing text from a text file, a single line feed or a line feed followed by a carriage return is converted into a space character. A line feed which is followed by another line feed is converted into a CEditableText::EParagraphDelimiter . When exporting text to a text file, lines wrap at the specified wrap width and paragraph delimiters are converted into CR/LFs pairs. |
Copyright ©2010 Nokia Corporation and/or its subsidiary(-ies).
All rights
reserved. Unless otherwise stated, these materials are provided under the terms of the Eclipse Public License
v1.0.