/*

* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <e32std.h>

#include <e32base.h>

#include <s32std.h>

#include <s32strm.h>

#include <s32stor.h>

#include <s32mem.h>

#include <s32file.h>

#include <s32ucmp.h>

#include <fepitfr.h>

#include "FLDDEF.H"

#include "FLDINFO.H"

#include "FLDSET.H"

#include "TXTETEXT.H"

#include "TXTRICH.H"

#include "TXTOPT.H"

#include "TXTFEP.H"

#include "TXTPLAIN.H"

#include "TXTSTD.H"

#include "TXTRTPFL.H"

#include "TXTCLIPBOARD.H"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "TXTETEXTTraces.h"

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TXTETEXT_INTERNAL.H"

#endif

const TUint KFieldCountLimit = 255;

#define UNUSED_VAR(a) a = a

// Write some or all of the text in a buffer to a stream, writing the length first if aWriteLength is true.

static void ExternalizeTextL(RWriteStream& aStream,const CBufBase& aText,TInt aPos,TInt aLength,TBool aWriteLength)

	{

	if (aWriteLength)

		aStream << TCardinality(aLength);

	// Use the Standard Unicode Compression Scheme.

	RBufReadStream input_stream(aText,aPos * sizeof(TText));

	TMemoryStreamUnicodeSource source(input_stream);

	TUnicodeCompressor c;

	c.CompressL(aStream,source,KMaxTInt,aLength);

	input_stream.Close();

	}

// Read text from a stream and write it to a buffer.

static void InternalizeTextL(RReadStream& aStream,CBufBase& aText,TInt aLength)

	{

	// Use the Standard Unicode Compression Scheme.

	RBufWriteStream output_stream(aText);

	TMemoryStreamUnicodeSink sink(output_stream);

	TUnicodeExpander e;

	e.ExpandL(sink,aStream,aLength);

	output_stream.CommitL();

	output_stream.Close();

	}

// Read text from a stream and write it to a buffer; read the length first.

static void InternalizeTextL(RReadStream& aStream,CBufBase& aText)

	{

	TCardinality length;

	aStream >> length;

	InternalizeTextL(aStream,aText,length);

	}

/**

Returns the interface corresponding to the

specified UID if it exists, or 0 if not. Overridden

versions should base call rather than returning 0.

@param aInterfaceId The UID indicating the interface to return

@param aInterface The interface corresponding to aInterfaceId

if it is supported, or 0 if it is not

*/

EXPORT_C void CEditableText::ExtendedInterface(TAny*& /*aInterface*/, TUid /*aInterfaceId*/) {}

/**

Returns the interface corresponding to the

specified UID if it exists, or 0 if not. Overridden

versions should base call rather than returning 0.

@param aInterfaceId The UID indicating the interface to return

@param aInterface The interface corresponding to aInterfaceId

if it is supported, or 0 if it is not

*/

EXPORT_C void CPlainText::ExtendedInterface(TAny*& /*aInterface*/, TUid /*aInterfaceId*/) {}

/**

 @internalAll

 @released

 */

EXPORT_C void CPlainText::Reserved_2() {}

//////////////////////////////////

// CEditableText

//////////////////////////////////

EXPORT_C CEditableText::~CEditableText()

	{

	delete iOptionalData;

	}

EXPORT_C TInt CEditableText::ScanWords(TInt& /*aPos*/,TUint& /*aScanMask*/) const

/** Scans the text from a specified document position to a location 

determined by the flags specified in a bitmask. The function can scan 

forwards or backwards to the beginning or end of a word.

@param aPos A valid document position from which to scan. On return, 

contains the new document position. 

@param aScanMask The scan mask to use. See the scanning enumeration defined 

in class CPlainText. 

@return The number of characters skipped to reach the new document position. 

Notes: If the scan passes 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. */

	{

	return 0;

	}

EXPORT_C TInt CEditableText::ScanParas(TInt& /*aPos*/,TUint& /*aScanMask*/) const

/** Scans the text from a specified document position to a location determined 

by the flags specified in a bitmask. The function can scan forwards or backwards 

to the beginning or end of a paragraph.

@param aPos A valid document position from which to scan. On return, contains 

the new document position. 

@param aScanMask The scan mask to use. See the scanning enumeration defined 

in class CPlainText. 

@return The number of characters skipped to reach the new document position. 

Notes: If the scan passes 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. */

	{

	return 0;

	}

EXPORT_C void CEditableText::SetHasChanged(TBool aHasChanged)

/** Sets whether a change has occurred to the editable text object. This is called 

by functions which change the text object in some way.

@param aHasChanged ETrue if a change has occurred to the text object. EFalse 

if no change has occurred. */

	{

	iHasChanged = aHasChanged;

	}

// Save the editable text type identifier.

void CEditableText::ExternalizeL(RWriteStream& aStream)const

	{

	aStream << KEditableTextUid;

	}

void CEditableText::InternalizeL(RReadStream& aStream)

// Read from the stream, expecting the editable text type identifier

//

	{

	TUid uid;

	aStream>> uid;

	if (uid!=KEditableTextUid)

		User::Leave(KErrCorrupt);

	}

EXPORT_C TStreamId CEditableText::StoreL(CStreamStore& aStore)const

/** Stores the text and its components. The components (e.g. fields and pictures) 

are stored in separate streams within the stream store.

@param aStore Stream store to which the text and text components are written. 

@return The ID of the stream store. */

	{

	CStoreMap* map=CStoreMap::NewLC(aStore);

	StoreComponentsL(aStore,*map);

//

	RStoreWriteStream stream(*map);

	TStreamId id=stream.CreateLC(aStore);

	stream<< *this;

	stream.CommitL();

//

	map->Reset();

	CleanupStack::PopAndDestroy(2);  // map,stream

	return id;

	}

EXPORT_C void CEditableText::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)

/** Restores the text and its components from a stream store.

@param aStore Stream store containing the text and its components. 

@param aStreamId The ID of the stream store in which the text was previously 

stored. */

	{

	// Load text and field components only.  (Pictures, if present, are deferred loaded).

	__ETEXT_WATCH(RESTORE)

	RStoreReadStream stream;

	stream.OpenLC(aStore,aStreamId);

	//

	stream>> *this;

	CleanupStack::PopAndDestroy();  // stream

	RestoreComponentsL(aStore);

	__ETEXT_WATCH_END(RESTORE)

	}

TBool CEditableText::DeleteWithoutDestroyingFormatL(TInt aPos, TInt aLength)

/** Deletes a range of characters. For rich text the format of the deleted character 

at position aPos is preserved, so that any text subsequently inserted at aPos will have 

that format applied to it.

@param aPos The document position from which to begin deleting including aPos.

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

@return Indicates whether two paragraphs have been merged together as a result 

of the delete, indicating that the resulting paragraph must be reformatted. 

*/	

	{

	TAny* richTextInterface = NULL;	

	ExtendedInterface(richTextInterface, KUidRichText);

	if(richTextInterface)

		{

		return REINTERPRET_CAST(CRichText*, richTextInterface)->DelSetInsertCharFormatL(aPos, aLength);

		}

	else

		{

		return DeleteL(aPos, aLength);

		}

	}

EXPORT_C void CEditableText::StartFepInlineEditL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument,const TDesC& aInitialInlineText,TInt aPositionOfInlineTextInDocument,TInt aNumberOfCharactersToHide,MFepInlineTextFormatRetriever& aInlineTextFormatRetriever)

/** @internalAll */	

	{

	if (aPositionOfInlineTextInDocument<0 || aNumberOfCharactersToHide<0 || aPositionOfInlineTextInDocument+aNumberOfCharactersToHide>DocumentLength())

	    {

	    OstTrace0( TRACE_DUMP, CEDITABLETEXT_STARTFEPINLINEEDITL, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPositionOfInlineTextInDocument>=0 && aNumberOfCharactersToHide>=0 && aPositionOfInlineTextInDocument+aNumberOfCharactersToHide<=DocumentLength(),Panic(ECharPosBeyondDocument));

	if (InlineEditData()!=NULL)

	    {

	    OstTrace0( TRACE_DUMP, DUP1_CEDITABLETEXT_STARTFEPINLINEEDITL, "EAlreadyFepInlineEditing" );

	    }

	__ASSERT_ALWAYS(InlineEditData()==NULL,Panic(EAlreadyFepInlineEditing));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	CInlineEditData* const inlineEditData=new(ELeave) CInlineEditData;

	CleanupStack::PushL(inlineEditData);

	HBufC* hiddenText=NULL;

	CleanupStack::PushL(hiddenText);

	if (aNumberOfCharactersToHide>0)

		{

		CleanupStack::Pop(); // hiddenText

		hiddenText=HBufC::NewLC(aNumberOfCharactersToHide);

		TPtr hiddenTextAsWritableDescriptor=hiddenText->Des();

		Extract(hiddenTextAsWritableDescriptor,aPositionOfInlineTextInDocument,aNumberOfCharactersToHide);

		aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(aPositionOfInlineTextInDocument,aNumberOfCharactersToHide);

		aNumberOfCharactersSuccessfullyDeleted=aNumberOfCharactersToHide;

		aPositionOfInsertionPointInDocument=aPositionOfInlineTextInDocument;

		}

	inlineEditData->iPositionOfInlineTextInDocument=aPositionOfInlineTextInDocument;

	inlineEditData->iLengthOfInlineText=aInitialInlineText.Length();

	inlineEditData->iInlineText=aInitialInlineText.AllocL();

	inlineEditData->iHiddenText=hiddenText;

	CleanupStack::Pop(); // hiddentext now owned by inlineEditData. 

	inlineEditData->iInlineTextFormatRetriever=&aInlineTextFormatRetriever;

	InsertL(aPositionOfInlineTextInDocument,aInitialInlineText);

	SetAndTransferOwnershipOfInlineEditDataL(inlineEditData);

	CleanupStack::Pop(); // inlineEditData

	aNumberOfCharactersSuccessfullyInserted=inlineEditData->iLengthOfInlineText;

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	}

EXPORT_C void CEditableText::UpdateFepInlineTextL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument,const TDesC& aNewInlineText)

/** @internalAll */	

    {

	CInlineEditData* const inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

	    {

	    OstTrace0( TRACE_DUMP, CEDITABLETEXT_UPDATEFEPINLINETEXTL, "ENotCurrentlyFepInlineEditing" );

	    }

	__ASSERT_ALWAYS(inlineEditData!=NULL,Panic(ENotCurrentlyFepInlineEditing));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	HBufC*& inlineText=inlineEditData->iInlineText;

	HBufC* oldInlineText=inlineText;

	if (oldInlineText!=NULL && inlineEditData->iLengthOfInlineText!=oldInlineText->Length())

	    {

	    OstTrace0( TRACE_DUMP, DUP1_CEDITABLETEXT_UPDATEFEPINLINETEXTL, "EDebug" );

	    }

	__ASSERT_DEBUG(oldInlineText==NULL || inlineEditData->iLengthOfInlineText==oldInlineText->Length(),Panic(EDebug));

	const TInt lengthOfNewInlineText=aNewInlineText.Length();

	if (oldInlineText!=NULL && *oldInlineText==aNewInlineText)

		{

		aNumberOfCharactersSuccessfullyDeleted=lengthOfNewInlineText;

		aNumberOfCharactersSuccessfullyInserted=lengthOfNewInlineText;

		}

	else

		{

		if (oldInlineText==NULL)

			{

			oldInlineText=HBufC::NewL(lengthOfNewInlineText);

			}

		else if (lengthOfNewInlineText>oldInlineText->Length())

			{

			oldInlineText=oldInlineText->ReAllocL(lengthOfNewInlineText);

			}

		CleanupStack::PushL(oldInlineText);

		inlineText=NULL; // sets inlineEditData->iLengthOfInlineText in case either the delete or the insert leaves

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		TInt& lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		if (lengthOfInlineText>0)

			{

			aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(positionOfInlineTextInDocument,lengthOfInlineText);

			aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

			lengthOfInlineText=0; // sets inlineEditData->iLengthOfInlineText in case the insert leaves

			aPositionOfInsertionPointInDocument=inlineEditData->iPositionOfInlineTextInDocument;

			}

		InsertL(positionOfInlineTextInDocument,aNewInlineText);

		lengthOfInlineText=aNewInlineText.Length(); // sets inlineEditData->iLengthOfInlineText

		aNumberOfCharactersSuccessfullyInserted=lengthOfInlineText;

		inlineText=oldInlineText;

		CleanupStack::Pop(); // oldInlineText

		*oldInlineText=aNewInlineText;

		}

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	}

EXPORT_C void CEditableText::CommitFepInlineEditL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument)

/**

 * @internalAll

 */	

    {

	const CInlineEditData* const inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CEDITABLETEXT_COMMITFEPINLINEEDITL, "ENotCurrentlyFepInlineEditing" );

	    }

	__ASSERT_ALWAYS(inlineEditData!=NULL,Panic(ENotCurrentlyFepInlineEditing));

	if (inlineEditData->iInlineText!=NULL && inlineEditData->iLengthOfInlineText!=inlineEditData->iInlineText->Length())

	    {

	    OstTrace0( TRACE_DUMP, CEDITABLETEXT_COMMITFEPINLINEEDITL, "EDebug" );

	    }

	__ASSERT_DEBUG(inlineEditData->iInlineText==NULL || inlineEditData->iLengthOfInlineText==inlineEditData->iInlineText->Length(),Panic(EDebug));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

	aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

	aNumberOfCharactersSuccessfullyInserted=lengthOfInlineText;

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	DeleteInlineEditDataAndSetToNull();

	}

EXPORT_C void CEditableText::CancelFepInlineEdit(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument)

/**

 * @internalAll

 */	

    {

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData!=NULL)

		{

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		if (inlineEditData->iInlineText!=NULL && lengthOfInlineText!=inlineEditData->iInlineText->Length())

		    {

		    OstTrace0( TRACE_DUMP, CEDITABLETEXT_CANCELFEPINLINEEDIT, "EDebug" );

		    }

		__ASSERT_DEBUG(inlineEditData->iInlineText==NULL || lengthOfInlineText==inlineEditData->iInlineText->Length(),Panic(EDebug));

		TRAPD(notUsed,

						if (lengthOfInlineText>0)

							{

							aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(positionOfInlineTextInDocument,lengthOfInlineText);

							aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

							aPositionOfInsertionPointInDocument=inlineEditData->iPositionOfInlineTextInDocument;

							}

						const HBufC* const hiddenText=inlineEditData->iHiddenText;

						if (hiddenText!=NULL)

							{

							if (hiddenText->Length()<=0)

							    {

							    OstTrace0( TRACE_DUMP, DUP1_CEDITABLETEXT_CANCELFEPINLINEEDIT, "EDebug" );

							    }

							__ASSERT_DEBUG(hiddenText->Length()>0, Panic(EDebug));

							InsertL(positionOfInlineTextInDocument,*hiddenText);

							aNumberOfCharactersSuccessfullyInserted=hiddenText->Length();

							aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

							}

			);

        UNUSED_VAR(notUsed);

		DeleteInlineEditDataAndSetToNull();

		}

	}

EXPORT_C void CEditableText::OverrideFormatOfInlineTextIfApplicable(TPtrC& aView,TCharFormat& aFormat,TInt aStartPos)const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData!=NULL)

		{

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		const TInt originalLengthOfView=aView.Length();

		TInt maximumLengthOfView=originalLengthOfView;

		if (aStartPos<positionOfInlineTextInDocument)

			{

			maximumLengthOfView=positionOfInlineTextInDocument-aStartPos;

			}

		else if (aStartPos<positionOfInlineTextInDocument+lengthOfInlineText)

			{

			inlineEditData->iInlineTextFormatRetriever->GetFormatOfFepInlineText(aFormat,maximumLengthOfView,aStartPos-positionOfInlineTextInDocument);

			}

		if (originalLengthOfView>maximumLengthOfView)

			{

			aView.Set(aView.Left(maximumLengthOfView));

			}

		}

	}

EXPORT_C TInt CEditableText::GetPositionOfInlineTextInDocument() const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

		return KErrNotFound;

	return inlineEditData->iPositionOfInlineTextInDocument;	

	}

EXPORT_C TInt CEditableText::GetLengthOfInlineText() const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

		return KErrNotFound;

	return inlineEditData->iLengthOfInlineText;		

	}

//////////////////////////////////

// TEtextComponentInfo

//////////////////////////////////

EXPORT_C TEtextComponentInfo::TEtextComponentInfo()

	: iFieldCount(0),iPictureCount(0),iStyleCount(0)

/** C++ constructor overloaded function.

The object can be constructed either:by default this initializes the

field, picture and style counts to zerowith a field, picture and style

count

@param aFieldCount Specifies the number of fields in the text object.

@param aPictureCount Specifies the number of pictures in the text object

(rich text only).

@param aStyleCount  Specifies the number of styles owned or referenced by

the text object (rich text only). */

    {}

EXPORT_C TEtextComponentInfo::TEtextComponentInfo(TInt aFieldCount,TInt aPictureCount,TInt aStyleCount)

	: iFieldCount(aFieldCount),iPictureCount(aPictureCount),iStyleCount(aStyleCount)

/** C++ constructor overloaded function. The object can be constructed either:

by default  this initializes the field, picture and style counts to zero

with a field, picture and style count

@param aFieldCount Specifies the number of fields in the text object. 

@param aPictureCount Specifies the number of pictures in the text object (rich 

text only). 

@param aStyleCount Specifies the number of styles owned or referenced by the 

text object (rich text only). */

	{}

//////////////////////////////////

// CPlainText

//////////////////////////////////

EXPORT_C void CPlainText::__DbgTestInvariant()const

// Provides class invariants.  Explanations below:

//

	{

#ifdef _DEBUG

// ASSERT: Storage handle is good.

	__ASSERT_DEBUG(iByteStore!=NULL,User::Invariant());

// ASSERT: The text component must be non-negative in length

	__ASSERT_DEBUG(DocumentLength()>=0,User::Invariant());

#endif

	}

EXPORT_C CPlainText* CPlainText::NewL(TDocumentStorage aStorage,TInt aDefaultTextGranularity)

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

@param aStorage  The type of in-memory buffer to use. Defaults to ESegmentedStorage.

@param aDefaultTextGranularity  Specifies the granularity of the in-memory 

buffer. Default is EDefaultTextGranularity bytes (=256).

@param aStore   Stream store from which the object is restored.

@param aStreamId  ID of the stream store.

@param aFieldFactory Pointer to a field factory. A field factory must be

provided if the text object supports the addition of fields.

@return Pointer to the new plain text object. */	

	{

	CPlainText* self=new(ELeave) CPlainText();

	CleanupStack::PushL(self);

	self->ConstructL(aStorage,aDefaultTextGranularity);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CPlainText* CPlainText::NewL(const CStreamStore& aStore,TStreamId aStreamId,MTextFieldFactory* aFieldFactory,TDocumentStorage aStorage)

/** Returns a handle to a new instance of this class, restored from the specified

read stream.*/

	{

	CPlainText* self=new(ELeave) CPlainText();

	CleanupStack::PushL(self);

	self->ConstructL(aStore,aStreamId,aFieldFactory,aStorage);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CPlainText::CPlainText()

	{

	SetHasChanged(EFalse);

	}

EXPORT_C void CPlainText::ConstructL(TDocumentStorage aStorage,TInt aDefaultTextGranularity)

/** Allocates storage of CBufFlat or CBufSeg, according

to the parameter aStorage.

Creates & initializes the field set.*/

	{

	DoConstructL(aStorage,aDefaultTextGranularity);

	InsertEodL();

	__TEST_INVARIANT;

	}

EXPORT_C void CPlainText::ConstructL(const CStreamStore& aStore,TStreamId aStreamId,MTextFieldFactory* aFieldFactory,

									 TDocumentStorage aStorage)

/** Allocates storage of CBufFlat or CBufSeg, according

 to the parameter aStorage, restoring contents from the specified read-stream aStream.*/

	{

	DoConstructL(aStorage,EDefaultTextGranularity,aFieldFactory);	

	RestoreL(aStore,aStreamId);

	__TEST_INVARIANT;

	}

EXPORT_C void CPlainText::DoConstructL(TDocumentStorage aStorage,TInt aDefaultTextGranularity,MTextFieldFactory* aFieldFactory)

/** Allocates storage of CBufFlat or CBufSeg, according to the parameter aStorage.

Creates & initializes the field set.*/

	{

	if (iByteStore!=NULL)

	    {

	    OstTrace0( TRACE_DUMP, CPLAINTEXT_DOCONSTRUCTL, "EConstructCalledTwice" );

	    }

	__ASSERT_DEBUG(iByteStore==NULL,Panic(EConstructCalledTwice));

	iByteStore=(aStorage==ESegmentedStorage)

		? (CBufBase*)CBufSeg::NewL(aDefaultTextGranularity*sizeof(TText))

		: (CBufBase*)CBufFlat::NewL(aDefaultTextGranularity*sizeof(TText));

	if (aFieldFactory)

		SetFieldFactory(aFieldFactory);

	}

EXPORT_C CPlainText::~CPlainText()

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

destruction. */

	{

	KillFieldSet();

	delete iByteStore;

	}

void CPlainText::KillFieldSet()

/** Delete the field set if it is resident in memory.*/

	{

	if (FieldSetPresent())

		delete iFieldSet.AsPtr();

	iFieldSet=NULL;

	}

//

// CPlainText - Persistence

EXPORT_C void CPlainText::StoreComponentsL(CStreamStore& aStore,CStoreMap& aMap)const

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

@param aStore Stream store to which the text object's components are written. 

@param 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. */

	{

	// Store any field components, then store the field set out-of-line, if present.

	if (FieldSetPresent())

		{

		TStreamId id=iFieldSet->StoreL(aStore);

		aMap.BindL(iFieldSet,id);

		}

	}

EXPORT_C void CPlainText::RestoreComponentsL(const CStreamStore& aStore)

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

@param aStore The stream store from which the field set is restored. */

	{

	// Load the field set, and load any referenced pictures

	TStreamId id=iFieldSet.AsId();

	if (id!=KNullStreamId)

		{

		CreateFieldSetL(0);

		iFieldSet->SetFieldFactory(iFieldFactory);

		iFieldSet->RestoreL(aStore,id);

		}

	}

EXPORT_C void CPlainText::StoreFieldComponentsL(CStreamStore& aStore,CStoreMap& aMap)const

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

@param aStore Stream store to which the fields are written. 

@param 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. */

	{

	// 2' StoreComponents() 

	// Only has effect if a field set is present.

	if (FieldSetPresent())

		iFieldSet->StoreFieldsL(aStore,aMap);

	}

EXPORT_C void CPlainText::RestoreFieldComponentsL(const CStreamStore& aStore)

/** Restores the plain text object's field set.

@param aStore The stream store from which the fields are restored. */

	{

	// 2' RestoreComponents()

	// Only has effect if a field set is present - (has been Internalized())

	if (FieldSetPresent())

		iFieldSet->RestoreFieldsL(aStore);

	}

EXPORT_C void CPlainText::ExternalizeL(RWriteStream& aStream)const

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

@param aStream Stream to which the object should be externalised. */

	{

	// Store this object in the specified write-stream.

	CEditableText::ExternalizeL(aStream);

	DoExternalizeFieldDataL(aStream);

	DoExternalizePlainTextL(aStream);

	}

EXPORT_C void CPlainText::InternalizeL(RReadStream& aStream)

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

@param aStream Stream from which the object should be internalised. */

	{

	// Restores plain text from the specified read-stream.

	// Internalize has construction semantics, not assignment semantics.

	CEditableText::InternalizeL(aStream);

	DoInternalizeFieldDataL(aStream);

	DoInternalizePlainTextL(aStream);

	__TEST_INVARIANT;

	}

EXPORT_C void CPlainText::ExternalizeFieldDataL(RWriteStream& aStream)const

/** Externalises the plain text object's field set.

@param aStream The stream to which the field set should be written. */

	{

	// Save just the field set

	__TEST_INVARIANT;

	TUint fieldCount=(TUint)FieldCount();

	if(fieldCount<KFieldCountLimit)

		aStream.WriteUint8L(fieldCount);

	else

		{

		aStream.WriteUint8L(KFieldCountLimit);

		aStream.WriteUint32L(fieldCount);

		}

	if (fieldCount>0)

		aStream<< *iFieldSet;

	}

EXPORT_C void CPlainText::InternalizeFieldDataL(RReadStream& aStream)

/** Internalizes the field set.

@param aStream The read stream from which the field set is read. */

	{

	// 2' InternalizeL()

	// Restores field records from the specified read-stream.

	// Internalize has construction semantics, not assignment semantics.

	TUint fieldCount=aStream.ReadUint8L();

	if (fieldCount==KFieldCountLimit)

		fieldCount=aStream.ReadUint32L();

	if (fieldCount>0)

		{

		if (!iFieldSet)

			CreateFieldSetL(DocumentLength());

		aStream>> *iFieldSet;

		}

	}

EXPORT_C void CPlainText::DoInternalizeFieldDataL(RReadStream& aStream)

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

	{

	TUid uid=UidFromStreamL(aStream);

	while (uid!=KPlainTextFieldDataUid)

 		{

		if (uid==KPlainTextCharacterDataUid)

			User::Leave(KErrCorrupt);  // There is no field Data !!!!!

		CPlainText::ConsumeAdornmentL(aStream);

		uid=UidFromStreamL(aStream);

		}

	if (FieldSetPresent())

		iFieldFactory=iFieldSet->FieldFactory();

	KillFieldSet();

	aStream>> iFieldSet;  // a swizzle

	}

EXPORT_C void CPlainText::DoExternalizeFieldDataL(RWriteStream& aStream)const

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

	{

	aStream<< KPlainTextFieldDataUid;

	if (FieldSetPresent())

		aStream<< iFieldSet;

	else

		aStream<< KNullStreamId;

	}

EXPORT_C void CPlainText::DoExternalizePlainTextL(RWriteStream& aStream)const

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

	{

	aStream<< KPlainTextCharacterDataUid;

	ExternalizePlainTextL(aStream);

	}

EXPORT_C void CPlainText::ExternalizePlainTextL(RWriteStream& aStream)const

/** Externalises the plain text object's text content (preceded by a length count) 

to a write stream.

@param aStream Stream to which the text content should be externalised. */

	{

	// Save just the bytestore

	__TEST_INVARIANT;

	::ExternalizeTextL(aStream,*iByteStore,0,iByteStore->Size() / sizeof(TText),TRUE);

	}

EXPORT_C void CPlainText::DoInternalizePlainTextL(RReadStream& aStream)

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

	{

	TUid uid=UidFromStreamL(aStream);

	while (uid!=KPlainTextCharacterDataUid)

		{

		CPlainText::ConsumeAdornmentL(aStream);

		uid=UidFromStreamL(aStream);

		}

	CPlainText::InternalizePlainTextL(aStream);

	}

EXPORT_C void CPlainText::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.

@param aStream Stream from which the object should be internalised.

@param  aLength Indicates the number of characters which should be

read, after expansion from their compressed format. */	

    {

	// Restores plain text content from the specified read-stream.

	// Internalize has construction semantics, not assignment semantics.

	::InternalizeTextL(aStream,*iByteStore);

	SetHasChanged(EFalse);

	__TEST_INVARIANT;

	}

EXPORT_C void CPlainText::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.

@see void CPlainText::ExternalizePlainTextL(RWriteStream& aStream)const

@deprecated */

	{

	::ExternalizeTextL(aStream,*iByteStore,0,iByteStore->Size() / sizeof(TText),FALSE);

	}

EXPORT_C void CPlainText::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. 

@param aStream Stream from which the object should be internalised. 

@param aLength Indicates the number of characters which should be read, after 

expansion from their compressed format. 

@deprecated */

	{

	::InternalizeTextL(aStream,*iByteStore,aLength);

	}

// Copy the specified section of plain text to the specified store.

EXPORT_C void CPlainText::CopyToStoreL(CStreamStore& aStore,CStreamDictionary& aDictionary,TInt aPos,TInt aLength) const

/** 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

@param aStore Stream store to which the text is written. 

@param aDictionary The stream dictionary. 

@param aPos The document position from which to begin copying. 

@param aLength The number of characters to copy. */

	{

	if (aLength > 0)

		DoCopyToStoreL(aStore,aDictionary,aPos,aLength);

	}

TStreamId CPlainText::DoCopyToStoreL(CStreamStore& aStore,CStreamDictionary& aDictionary,TInt aPos,TInt aLength) const

	{

	__TEST_INVARIANT;

	TInt documentLength = DocumentLength();

	if (aPos < 0 || aPos > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, CPLAINTEXT_DOCOPYTOSTOREL, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos >= 0 && aPos <= documentLength,Panic(ECharPosBeyondDocument));

	if (aLength < 0)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CPLAINTEXT_DOCOPYTOSTOREL, "ECopyToStreamNegativeLength" );

	    }

	__ASSERT_ALWAYS(aLength >= 0,Panic(ECopyToStreamNegativeLength));

	if (aPos + aLength > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CPLAINTEXT_DOCOPYTOSTOREL, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos + aLength <= documentLength,Panic(ECharPosBeyondDocument));

	if (aLength == 0)

		return KNullStreamId;

	CStoreMap* map=CStoreMap::NewLC(aStore);

	CopyComponentsL(aStore,*map,aPos,aLength);

	// create custom externalizer over the map

	TFieldMapExternalizer fMap(*map);

	RStoreWriteStream stream(fMap);

	TStreamId id=stream.CreateLC(aStore);

	CopyToStreamL(stream,aPos,aLength);

	stream.CommitL();

	aDictionary.AssignL(KClipboardUidTypePlainText,id);

	map->Reset();

	CleanupStack::PopAndDestroy(2);

	__TEST_INVARIANT;

	return id;

	}

void CPlainText::CopyComponentsL(CStreamStore& aStore,CStoreMap& aMap,TInt aPos,TInt aLength)const

// Copy/Paste 2' StoreComponentsL() - only if a field set is present.

// 

	{

	if (FieldSetPresent())

		iFieldSet->CopyComponentsL(aStore,aMap,aPos,aLength);

	}

// Write the plain text to the stream.

void CPlainText::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength)const

	{

	__TEST_INVARIANT;

	TInt documentLength = DocumentLength();

	if (aPos < 0 || aPos > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, CPLAINTEXT_COPYTOSTREAML, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos >= 0 && aPos <= documentLength,Panic(ECharPosBeyondDocument));

	if (aLength < 0)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CPLAINTEXT_COPYTOSTREAML, "ECopyToStreamNegativeLength" );

	    }

	__ASSERT_ALWAYS(aLength >= 0,Panic(ECopyToStreamNegativeLength));

	if (aPos + aLength > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CPLAINTEXT_COPYTOSTREAML, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos + aLength <= documentLength,Panic(ECharPosBeyondDocument));