CPlainText Class Reference

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.

Inherits from

Public Member Functions
~CPlainText ()
IMPORT_C TInt CharPosOfParagraph ( TInt &, TInt )
IMPORT_C TEtextComponentInfo ComponentInfo ()
IMPORT_C void ConvertAllFieldsToText ()
IMPORT_C TBool ConvertFieldToText ( TInt )
IMPORT_C void CopyToStoreL ( CStreamStore &, CStreamDictionary &, TInt , TInt )
IMPORT_C TBool DeleteL ( TInt , TInt )
IMPORT_C TInt DocumentLength ()
IMPORT_C void ExportAsTextL (const TDes &, TTextOrganisation , TInt )
IMPORT_C void ExportTextL ( TInt , RWriteStream &, TTextOrganisation , TInt , TInt , TInt , TInt *, TInt *)
IMPORT_C void ExportTextL ( TInt , RWriteStream &, const TImportExportParam &, TImportExportResult &)
IMPORT_C void ExtendedInterface ( TAny *&, TUid )
IMPORT_C void ExternalizeFieldDataL ( RWriteStream &)
IMPORT_C void ExternalizeL ( RWriteStream &)
IMPORT_C void ExternalizePlainTextL ( RWriteStream &)
IMPORT_C void ExternalizePlainTextNoLengthCountL ( RWriteStream &)
IMPORT_C void Extract ( TDes &, TInt )
IMPORT_C void Extract ( TDes &, TInt , TInt )
IMPORT_C void ExtractSelectively ( TDes &, TInt , TInt , TUint )
IMPORT_C TInt FieldCount ()
IMPORT_C const MTextFieldFactory * FieldFactory ()
IMPORT_C TBool FindFields ( TInt )
IMPORT_C TBool FindFields ( TFindFieldInfo &, TInt , TInt )
IMPORT_C void GetWordInfo ( TInt , TInt &, TInt &, TBool , TBool )
IMPORT_C TInt ImportTextFileL ( TInt , const TDes &, TTextOrganisation )
IMPORT_C void ImportTextL ( TInt , RReadStream &, TTextOrganisation , TInt , TInt , TInt *, TInt *)
IMPORT_C void ImportTextL ( TInt , RReadStream &, const TImportExportParam &, TImportExportResult &)
IMPORT_C void InsertFieldL ( TInt , CTextField *, TUid )
IMPORT_C void InsertL ( TInt , const TChar &)
IMPORT_C void InsertL ( TInt , const TDesC &)
IMPORT_C void InternalizeFieldDataL ( RReadStream &)
IMPORT_C void InternalizeL ( RReadStream &)
IMPORT_C void InternalizePlainTextL ( RReadStream &)
IMPORT_C void InternalizePlainTextL ( RReadStream &, TInt )
IMPORT_C CPlainText * NewL ( TDocumentStorage , TInt )
IMPORT_C CPlainText * NewL (const CStreamStore &, TStreamId , MTextFieldFactory *, TDocumentStorage )
IMPORT_C CTextField * NewTextFieldL ( TUid )
IMPORT_C TInt PageContainingPos ( TInt )
IMPORT_C TInt ParagraphCount ()
IMPORT_C TInt ParagraphNumberForPos ( TInt &)
IMPORT_C TInt PasteFromStoreL (const CStreamStore &, const CStreamDictionary &, TInt )
IMPORT_C TPtrC Read ( TInt )
IMPORT_C TPtrC Read ( TInt , TInt )
IMPORT_C TBool RemoveField ( TInt )
IMPORT_C void Reset ()
IMPORT_C void RestoreComponentsL (const CStreamStore &)
IMPORT_C void RestoreFieldComponentsL (const CStreamStore &)
IMPORT_C TInt ScanParas ( TInt &, TUint &)
IMPORT_C TInt ScanWords ( TInt &, TUint &)
IMPORT_C void SetFieldFactory ( MTextFieldFactory *)
IMPORT_C void SetPageTable ( TPageTable *)
IMPORT_C void StoreComponentsL ( CStreamStore &, CStoreMap &)
IMPORT_C void StoreFieldComponentsL ( CStreamStore &, CStoreMap &)
IMPORT_C const CTextField * TextField ( TInt )
IMPORT_C TInt ToParagraphStart ( TInt &)
IMPORT_C void UpdateAllFieldsL ()
IMPORT_C void UpdateFieldL ( TInt )
IMPORT_C TInt WordCount ()
Protected Member Functions
CPlainText ()
IMPORT_C void ConstructL ( TDocumentStorage , TInt )
IMPORT_C void ConstructL (const CStreamStore &, TStreamId , MTextFieldFactory *, TDocumentStorage )
void ConsumeAdornmentL ( RReadStream &)
void CopyComponentsL ( CStreamStore &, CStoreMap &, TInt , TInt )
void CopyToStreamL ( RWriteStream &, TInt , TInt )
TBool Delete ( TInt , TInt )
IMPORT_C void DoConstructL ( TDocumentStorage , TInt , MTextFieldFactory *)
TStreamId DoCopyToStoreL ( CStreamStore &, CStreamDictionary &, TInt , TInt )
IMPORT_C void DoExternalizeFieldDataL ( RWriteStream &)
IMPORT_C void DoExternalizePlainTextL ( RWriteStream &)
void DoExtract ( TDes &, TInt , TInt , TUint )
IMPORT_C void DoInternalizeFieldDataL ( RReadStream &)
IMPORT_C void DoInternalizePlainTextL ( RReadStream &)
TInt DoPasteFromStoreL (const CStreamStore &, TStreamId , TInt )
IMPORT_C TBool DoPtDelete ( TInt , TInt )
IMPORT_C void DoPtInsertL ( TInt , const TDesC &)
void InsertL ( TInt , const CPlainText *)
void PasteComponentsL (const CStreamStore &, TInt )
IMPORT_C void PtInsertL ( TInt , const TDesC &)
TUid UidFromStreamL ( RReadStream &)
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 &)
Inherited Functions
CBase::CBase()
CBase::Delete(CBase *)
CBase::Extension_(TUint,TAny *&,TAny *)
CBase::operator new(TUint)
CBase::operator new(TUint,TAny *)
CBase::operator new(TUint,TLeave)
CBase::operator new(TUint,TLeave,TUint)
CBase::operator new(TUint,TUint)
CBase::~CBase()
CEditableText::CancelFepInlineEdit(TBool &,TInt &,TInt &,TInt &,TInt)
CEditableText::CommitFepInlineEditL(TBool &,TInt &,TInt &,TInt &,TInt)
CEditableText::GetLengthOfInlineText()const
CEditableText::GetPositionOfInlineTextInDocument()const
CEditableText::HasChanged()const
CEditableText::OverrideFormatOfInlineTextIfApplicable(TPtrC &,TCharFormat &,TInt)const
CEditableText::RestoreL(const CStreamStore &,TStreamId)
CEditableText::SetHasChanged(TBool)
CEditableText::StartFepInlineEditL(TBool &,TInt &,TInt &,TInt &,TInt,const TDesC &,TInt,TInt,MFepInlineTextFormatRetriever &)
CEditableText::StoreL(CStreamStore &)const
CEditableText::UpdateFepInlineTextL(TBool &,TInt &,TInt &,TInt &,TInt,const TDesC &)
CEditableText::~CEditableText()
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

Constructor & Destructor Documentation

CPlainText()

IMPORT_C CPlainText ( ) [protected]

CPlainText(const CPlainText &)

CPlainText ( const CPlainText & aPlainTextDoc ) [private]

Parameters

const CPlainText & aPlainTextDoc

~CPlainText()

IMPORT_C ~CPlainText ( ) [virtual]

The destructor frees the object's text storage and field set, prior to its destruction.

Member Functions Documentation

CharPosOfParagraph(TInt &, TInt)

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

Parameters

TInt & aLength On return contains the length of the specified paragraph.
TInt aParaOffset The paragraph number. The first paragraph is numbered zero.

ComponentInfo()

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.

ConstructL(TDocumentStorage, TInt)

IMPORT_C void ConstructL ( TDocumentStorage aStorage = ESegmentedStorage,
TInt aDefaultTextGranularity = EDefaultTextGranularity
) [protected]

Allocates storage of CBufFlat or CBufSeg , according to the parameter aStorage. Creates & initializes the field set.

Parameters

TDocumentStorage aStorage = ESegmentedStorage
TInt aDefaultTextGranularity = EDefaultTextGranularity

ConstructL(const CStreamStore &, TStreamId, MTextFieldFactory *, TDocumentStorage)

IMPORT_C void ConstructL ( const CStreamStore & aStore,
TStreamId aStreamId,
MTextFieldFactory * aFieldFactory,
TDocumentStorage aStorage = ESegmentedStorage
) [protected]

Allocates storage of CBufFlat or CBufSeg , according to the parameter aStorage, restoring contents from the specified read-stream aStream.

Parameters

const CStreamStore & aStore
TStreamId aStreamId
MTextFieldFactory * aFieldFactory
TDocumentStorage aStorage = ESegmentedStorage

ConsumeAdornmentL(RReadStream &)

void ConsumeAdornmentL ( RReadStream & aStream ) [protected, static, inline]

Parameters

RReadStream & aStream

ConvertAllFieldsToText()

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.

ConvertFieldToText(TInt)

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.

Parameters

TInt aPos A document position within the field to convert. Must be a valid position or a panic occurs.

CopyComponentsL(CStreamStore &, CStoreMap &, TInt, TInt)

void CopyComponentsL ( CStreamStore & aStore,
CStoreMap & aMap,
TInt aPos,
TInt aLength
) const [protected]

Parameters

CStreamStore & aStore
CStoreMap & aMap
TInt aPos
TInt aLength

CopyToStoreL(CStreamStore &, CStreamDictionary &, TInt, TInt)

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

Parameters

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.

CopyToStreamL(RWriteStream &, TInt, TInt)

void CopyToStreamL ( RWriteStream & aStream,
TInt aPos,
TInt aLength
) const [protected]

Parameters

RWriteStream & aStream
TInt aPos
TInt aLength

CountUnits(TUnitOfText)

TInt CountUnits ( TUnitOfText aContext ) const [private]

Parameters

TUnitOfText aContext

CreateFieldSetL(TInt)

void CreateFieldSetL ( TInt aDocumentLength ) [private]

Parameters

TInt aDocumentLength

Delete(TInt, TInt)

TBool Delete ( TInt aPos,
TInt aLength
) [protected]

Parameters

TInt aPos
TInt aLength

DeleteL(TInt, TInt)

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.

Parameters

TInt aPos The document position from which to begin deleting. Must be valid or a panic occurs.
TInt aLength The number of characters to delete. Must be positive or a panic occurs. The sum of aPos and aLength must be less than the document length, or a panic occurs.

DoConstructL(TDocumentStorage, TInt, MTextFieldFactory *)

IMPORT_C void DoConstructL ( TDocumentStorage aStorage,
TInt aDefaultTextGranularity,
MTextFieldFactory * aFieldFactory = NULL
) [protected]

Allocates storage of CBufFlat or CBufSeg , according to the parameter aStorage. Creates & initializes the field set.

Parameters

TDocumentStorage aStorage
TInt aDefaultTextGranularity
MTextFieldFactory * aFieldFactory = NULL

DoCopyToStoreL(CStreamStore &, CStreamDictionary &, TInt, TInt)

TStreamId DoCopyToStoreL ( CStreamStore & aStore,
CStreamDictionary & aDictionary,
TInt aPos,
TInt aLength
) const [protected]

Parameters

CStreamStore & aStore
CStreamDictionary & aDictionary
TInt aPos
TInt aLength

DoExternalizeFieldDataL(RWriteStream &)

IMPORT_C void DoExternalizeFieldDataL ( RWriteStream & aStream ) const [protected]

Write to the stream, the T.V. representing the field set.

Parameters

RWriteStream & aStream

DoExternalizePlainTextL(RWriteStream &)

IMPORT_C void DoExternalizePlainTextL ( RWriteStream & aStream ) const [protected]

Write to the stream, the T.V. representing the plain text.

Parameters

RWriteStream & aStream

DoExtract(TDes &, TInt, TInt, TUint)

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.

Parameters

TDes & aBuf
TInt aPos
TInt aLength
TUint aFlags = 0

DoInternalizeFieldDataL(RReadStream &)

IMPORT_C void DoInternalizeFieldDataL ( RReadStream & aStream ) [protected]

Read from the stream until the field data is identified, and consume it.

Parameters

RReadStream & aStream

DoInternalizePlainTextL(RReadStream &)

IMPORT_C void DoInternalizePlainTextL ( RReadStream & aStream ) [protected]

Read from the stream until the character data is found, and consume it.

Parameters

RReadStream & aStream

DoPasteFromStoreL(const CStreamStore &, TStreamId, TInt)

TInt DoPasteFromStoreL ( const CStreamStore & aStore,
TStreamId aStreamId,
TInt aPos
) [protected]

Parameters

const CStreamStore & aStore
TStreamId aStreamId
TInt aPos

DoPasteFromStreamL(RReadStream &, TInt)

TInt DoPasteFromStreamL ( RReadStream & aStream,
TInt aPos
) [private]

Parameters

RReadStream & aStream
TInt aPos

DoPtDelete(TInt, TInt)

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.

Parameters

TInt aPos
TInt aLength

DoPtInsertL(TInt, const TDesC &)

IMPORT_C void DoPtInsertL ( TInt aPos,
const TDesC & aBuf
) [protected]

Inserts the contents a aBuf into the document at position aInsertPos. Maintain field set.

Parameters

TInt aPos
const TDesC & aBuf

DocumentLength()

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.

ExportAsTextL(const TDes &, TTextOrganisation, TInt)

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.

Parameters

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

ExportTextL(TInt, RWriteStream &, TTextOrganisation, TInt, TInt, TInt, TInt *, TInt *)

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.

Since
6.1

Parameters

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

ExportTextL(TInt, RWriteStream &, const TImportExportParam &, TImportExportResult &)

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

Parameters

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.

ExtendedInterface(TAny *&, TUid)

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.

Parameters

TAny *& aInterface The interface corresponding to aInterfaceId if it is supported, or 0 if it is not
TUid aInterfaceId The UID indicating the interface to return

ExternalizeFieldDataL(RWriteStream &)

IMPORT_C void ExternalizeFieldDataL ( RWriteStream & aStream ) const

Externalises the plain text object's field set.

Parameters

RWriteStream & aStream The stream to which the field set should be written.

ExternalizeL(RWriteStream &)

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.

Parameters

RWriteStream & aStream Stream to which the object should be externalised.

ExternalizePlainTextL(RWriteStream &)

IMPORT_C void ExternalizePlainTextL ( RWriteStream & aStream ) const

Externalises the plain text object's text content (preceded by a length count) to a write stream.

Parameters

RWriteStream & aStream Stream to which the text content should be externalised.

ExternalizePlainTextNoLengthCountL(RWriteStream &)

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

Parameters

RWriteStream & aStream

Extract(TDes &, TInt)

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.

Parameters

TDes & aBuf A buffer; on return contains the extracted text.
TInt aPos = 0 The document position from which to copy. Must be valid or a panic occurs.

Extract(TDes &, TInt, TInt)

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.

Parameters

TDes & aBuf A buffer; on return contains the extracted text.
TInt aPos The document position from which to copy. Must be valid or a panic occurs.
TInt aLength The number of characters to copy.

ExtractSelectively(TDes &, TInt, TInt, TUint)

IMPORT_C void ExtractSelectively ( TDes & aBuf,
TInt aPos,
TInt aLength,
TUint aFlags
)

Parameters

TDes & aBuf
TInt aPos
TInt aLength
TUint aFlags

FieldCount()

IMPORT_C TInt FieldCount ( ) const

Gets a count of the number of fields in the text object's field set.

FieldFactory()

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

FieldSetPresent()

TBool FieldSetPresent ( ) const [private, inline]

FindFields(TInt)

IMPORT_C TBool FindFields ( TInt aPos ) const

Parameters

TInt aPos

FindFields(TFindFieldInfo &, TInt, TInt)

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.

Parameters

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.

GetChar(SScanData &, TChar &)

TBool GetChar ( SScanData & aScanData,
TChar & aChar
) const [private]

Parameters

SScanData & aScanData
TChar & aChar

GetWordInfo(TInt, TInt &, TInt &, TBool, TBool)

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.

Parameters

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.

ImportTextFileL(TInt, const TDes &, TTextOrganisation)

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.

Parameters

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.

ImportTextL(TInt, RReadStream &, TTextOrganisation, TInt, TInt, TInt *, TInt *)

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.

Parameters

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.

ImportTextL(TInt, RReadStream &, const TImportExportParam &, TImportExportResult &)

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

Parameters

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.

InitScanControl(TInt &, TUint &, TUnitOfText, SScanData &)

void InitScanControl ( TInt & aPos,
TUint & aScanMask,
TUnitOfText aContext,
SScanData & aScanData
) const [private]

Parameters

TInt & aPos
TUint & aScanMask
TUnitOfText aContext
SScanData & aScanData

InitScanData(TInt, SScanData &)

void InitScanData ( TInt aPos,
SScanData & aScanData
) const [private]

Parameters

TInt aPos
SScanData & aScanData

InsertEodL()

void InsertEodL ( ) [private]

Inserts the end-of-document character upon document construction.

InsertFieldL(TInt, CTextField *, TUid)

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

Parameters

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.

InsertL(TInt, const TChar &)

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.

Parameters

TInt aPos The document position at which to insert the character/descriptor. Must be valid, or a panic occurs.
const TChar & aChar The character to insert.

InsertL(TInt, const TDesC &)

IMPORT_C void InsertL ( TInt aPos,
const TDesC & aBuf
) [virtual]

Inserts the contents of aBuf into the document at position aPos.

Parameters

TInt aPos
const TDesC & aBuf

InsertL(TInt, const CPlainText *)

void InsertL ( TInt aPos,
const CPlainText * aText
) [protected]

Insert the specified plain text object at the specified character position. (Called by CRichText::Insert()

Parameters

TInt aPos
const CPlainText * aText

InternalizeFieldDataL(RReadStream &)

IMPORT_C void InternalizeFieldDataL ( RReadStream & aStream )

Internalizes the field set.

Parameters

RReadStream & aStream The read stream from which the field set is read.

InternalizeL(RReadStream &)

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.

Parameters

RReadStream & aStream Stream from which the object should be internalised.

InternalizePlainTextL(RReadStream &)

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.

Parameters

RReadStream & aStream Stream from which the object should be internalised.

InternalizePlainTextL(RReadStream &, TInt)

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.

Parameters

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.

KillFieldSet()

void KillFieldSet ( ) [private]

Delete the field set if it is resident in memory.

NewL(TDocumentStorage, TInt)

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.

Parameters

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

NewL(const CStreamStore &, TStreamId, MTextFieldFactory *, TDocumentStorage)

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.

Parameters

const CStreamStore & aStore
TStreamId aStreamId
MTextFieldFactory * aFieldFactory = NULL
TDocumentStorage aStorage = ESegmentedStorage

NewTextFieldL(TUid)

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.

Parameters

TUid aFieldType Identifies the field type.

PageContainingPos(TInt)

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.

Parameters

TInt aPos A document position. Must be valid or a panic occurs.

ParagraphCount()

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.

ParagraphNumberForPos(TInt &)

IMPORT_C TInt ParagraphNumberForPos ( TInt & aPos ) const [virtual]

Gets the number of the paragraph which contains a document position. Paragraph numbering begins at zero.

Parameters

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.

PasteComponentsL(const CStreamStore &, TInt)

void PasteComponentsL ( const CStreamStore & aStore,
TInt aPos
) [protected]

Parameters

const CStreamStore & aStore
TInt aPos

PasteFromStoreL(const CStreamStore &, const CStreamDictionary &, TInt)

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.

Parameters

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.

PasteFromStreamL(RReadStream &, TInt)

TInt PasteFromStreamL ( RReadStream & aStream,
TInt aPos
) [private]

Parameters

RReadStream & aStream
TInt aPos

PtInsertL(TInt, const TDesC &)

IMPORT_C void PtInsertL ( TInt aInsertPos,
const TDesC & aBuf
) [protected]

Inserts the contents a aBuf into the document at position aInsertPos. Maintain field set.

Parameters

TInt aInsertPos
const TDesC & aBuf

Read(TInt)

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.

Parameters

TInt aStartPos The document position at which to begin reading. Must be valid or a panic occurs.

Read(TInt, TInt)

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.

Parameters

TInt aStartPos The document position at which to begin reading. Must be valid or a panic occurs.
TInt aLength The number of characters to read, inclusive of the character at position aStartPos.

RemoveField(TInt)

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.

Parameters

TInt aPos A document position within the field to be deleted. Must be a valid position or a panic occurs.

Reserved_2()

IMPORT_C void Reserved_2 ( ) [private, virtual]

Reset()

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.

RestoreComponentsL(const CStreamStore &)

IMPORT_C void RestoreComponentsL ( const CStreamStore & aStore ) [virtual]

Restores the plain text object's field set from a stream store.

Parameters

const CStreamStore & aStore The stream store from which the field set is restored.

RestoreFieldComponentsL(const CStreamStore &)

IMPORT_C void RestoreFieldComponentsL ( const CStreamStore & aStore )

Restores the plain text object's field set.

Parameters

const CStreamStore & aStore The stream store from which the fields are restored.

ScanParas(TInt &, TUint &)

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.

Parameters

TInt & aPos The document position to scan from. Must be valid or a panic occurs. On return, contains the new document position.
TUint & aScanMask The scan mask. See the enumeration whose values begin with CPlainText::EScanBackwards.

ScanUnit(TInt &, TUnitOfText, SScanData &)

TInt ScanUnit ( TInt & aPos,
TUnitOfText aContext,
SScanData & aScanData
) const [private]

Parameters

TInt & aPos
TUnitOfText aContext
SScanData & aScanData

ScanWords(TInt &, TUint &)

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.

Parameters

TInt & aPos The document position from which to scan. Must be valid, or a panic occurs. On return, contains the new document position.
TUint & aScanMask The scan mask. See the enumeration whose values begin with CPlainText::EScanBackwards.

SetFieldFactory(MTextFieldFactory *)

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.

Parameters

MTextFieldFactory * aFactory The field factory.

SetPageTable(TPageTable *)

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.

Parameters

TPageTable * aPageTable The page table to be referenced by the text object.

StoreComponentsL(CStreamStore &, CStoreMap &)

IMPORT_C void StoreComponentsL ( CStreamStore & aStore,
CStoreMap & aMap
) const [virtual]

Stores the plain text object's components to the stream store specified.

Parameters

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.

StoreFieldComponentsL(CStreamStore &, CStoreMap &)

IMPORT_C void StoreFieldComponentsL ( CStreamStore & aStore,
CStoreMap & aMap
) const

Stores the plain text object's field components to a stream store.

Parameters

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.

TestForDelimiter(TUnitOfText, SScanData &)

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.

Parameters

TUnitOfText aContext
SScanData & aScanData

TextField(TInt)

IMPORT_C const CTextField * TextField ( TInt aPos ) const

Returns a pointer to the field located at the specified document position.

Parameters

TInt aPos A document position within the field. Must be a valid document position, or a panic occurs.

ToParagraphStart(TInt &)

IMPORT_C TInt ToParagraphStart ( TInt & aPos ) const [virtual]

Gets the document position of the start of the paragraph containing the specified document position.

Parameters

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.

UidFromStreamL(RReadStream &)

TUid UidFromStreamL ( RReadStream & aStream ) [protected, static, inline]

Parameters

RReadStream & aStream

UpdateAllFieldsL()

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.

UpdateFieldL(TInt)

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.

Parameters

TInt aPos A document position in the field to be updated. Must be a valid position, or a panic occurs.

UpdatePageTable(TInt, TInt)

void UpdatePageTable ( TInt aPos,
TInt aLength
) [private]

Parameters

TInt aPos
TInt aLength

WordCount()

IMPORT_C TInt WordCount ( ) const [virtual]

Gets a count of the number of words in the text object.

operator=(const CPlainText &)

CPlainText & operator= ( const CPlainText & aPlainTextDoc ) [private]

Parameters

const CPlainText & aPlainTextDoc

Member Enumerations Documentation

Enum anonymous

Scan mask values.

Enumerators

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.

Enum anonymous

Enumerators

EExtractAll = 0
EExtractVisible = 1
EExcludeInlineEditedText = 2

Enum anonymous

Enumerators

EImportBufSize = 512
EBiggestCharacterPaste = 0x100000

Enum TScanDataEnd

Used in text scanning functions to indicate the end of the document has been passed.

Enumerators

EScanEndOfData = -1

Indicates that a scan has passed the end of text paragraph delimiter.

Enum TTextOrganisation

Line delimiter translation.

Enumerators

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.

Enum TUnitOfText

Enumerators

EUnitIsWord
EUnitIsParagraph

Member Data Documentation

__DECLARE_TEST

__DECLARE_TEST [protected]

CBufBase * iByteStore

CBufBase * iByteStore [protected]

MTextFieldFactory * iFieldFactory

MTextFieldFactory * iFieldFactory [protected]

TSwizzle< CTextFieldSet > iFieldSet

TSwizzle < CTextFieldSet > iFieldSet [protected]

TPageTable * iPageTable

TPageTable * iPageTable [protected]

void * iReserved_1

void * iReserved_1 [private]